Inexplicable segfault

Dear all

A friend of mine, used to program mainly in Java, is learning C++ for
professional reasons. I taught him the main differences between the
languages, and some programming guidelines. He applied them and came up
with an impressively well designed, cute code. The only problem is that
his program crashes, and that I cannot tell why.

All of this brings me into an awkward situation, confirming my
Java-programmer-friend's prejudice of C++ being as a language that is both
unpredictable and difficult to debug. I am therefore very grateful for any
suggestion on the matter.

You will find in the following a minimal version of the code that still
crashes. To be precise, it has an undefined behavior: you might need to
run it two or three times until it crashes. The code has been observed to
crash with GNU g++ (options -g -Wall) versions 3.3.6, 3.4.1, 3.4.2, 4.0.3
and 4.1.4, and with Intel icc (options -O0) version 7.0 . The test
machines had a Linux ia32 architecture. It can also be remarked that the
code does not crash when it is compiled with optimizing options.

Thanks for your help,
Jonas

#include <iostream>
#include <ostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <cstdlib>
#include <time.h>

class Individual {
public:
  Individual(int size) { build(size); }
  int size() const { return genome_.size(); }
  int& operator[](int i) { return genome_[i]; }
  double fitness() const { return compute_fitness(); }
  void randomize() { build(size()); }
  bool operator<( const Individual& rhs ) const {
    return this->fitness() < rhs.fitness();
  }
private:
  void build(int size) {
    genome_.resize(size);
    for (int i=0; i<size; ++i) {
      genome_[i] = rand() % 2;
    }
  }
  double compute_fitness() const {
    int sum = std::count( genome_.begin(), genome_.end(), 1 );
    double n = static_cast<double>( genome_.size() );
    return (n - sum) / n;
  }
private:
  std::vector<int> genome_;
};

class Population {
public:
  Population( const Individual& ind, int size ) : pop_(size,ind) {
    for(int i=0; i<size; ++i) {
      pop_[i].randomize();
    }
  }
  int size() const { return pop_.size(); }
  Individual& operator[](int i) { return pop_[i]; }
  void sort_indiv() { std::sort( pop_.begin(), pop_.end() ); }
private:
  std::vector<Individual> pop_;
};

int main( int argc, char** argv ) {
  const int indSize = 2000;
  const int popSize = 1000;

  srand ( time(NULL) );
  Individual populator(indSize);
  Individual indiv (indSize);

  Population pop(populator, popSize);

  for (int i=0; i<pop.size(); ++i) {
    pop[i] = indiv;
  }
  pop.sort_indiv();

  std::cout << "Best fitness:" << pop[0].fitness() << std::endl;
}

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]