从指针向量的向量中释放内存

Question

I'm creating a particle physics simulator and I need to make proper memory management.

I've found convenient that my method propagates several particles at once so this method returns a vector of trajectories and each trajectory is a vector of Steps (thus getting a vector< vector<> > ).

(Step is a class I created.)

vector< vector<Step*> > Propagator::Propagate (vector<TParticle*> vpart) {
  vector< vector<Step*> > = vvsteps;
  //vvsteps goes through physics and gets filled using push_back
  //all of vvsteps' entries were filled with objects created with "new"

  return vvsteps;
}

Each Step creates a vector of pointers to TParticle (created with new) and has the following destructor to deallocate it.

vector<TParticle*> vpart;

Step::~Step() {
  for(int i=0; i<vpart.size(); i++) delete vpart[i];
  vpart.clear();
}

After I get what I want I try to deallocate the whole thing by doing:

vector< vector<Step*> > vvstep = prop->Propagate(vpart);

/*PHYSICS GOES HERE*/

for(int i=0; i<vvstep.size(); i++) {
  for(int j=0; j<vvstep[i].size(); j++)
    delete (vvstep[i])[j];
  vvstep[i].clear();
}
vvstep.clear();

This code for some reason doesn't work. It gives me the following error

*** glibc detected *** bin/rtest.exe: double free or corruption (fasttop): 0x0f7207f0 ***

edit: corrected a typo, the class is named Step and not Steps.

Answer 1

Change your vector of vector type to:

`std::vector< std::vector<std::unique_ptr<Step>>>`

This does a few things. First, it blocks copying your std::vector s around, which is bad because such vectors represent both ownership and reference to data.

move is still available, and should generally occur. If you want to move one set of vectors of vectors to another spot, and it isn't happening automatically, insert a std::move( src ) .

Second, when the vector of vector of data goes out of scope, the unique_ptr automatically cleans up the Step objects.

You may have to insert some .get() calls on the unique_ptr<Base> in cases where you are calling a function that takes a Base* directly. But it should otherwise be mostly transparent.

Note that the double deletion is probably occuring because you have duplicated one of these vector s of Base* -- the std::vector<std::unique_ptr<Base>> will complain when you tried to do that...