Question

I’m new to C++ and have a question regarding memory management.

In the header, I have this:

std::vector<Obstacle::Obstacle*> obstacles;

and in the .cpp I do this:

Circle *circle = new Circle(x, y, radius);
obstacles.push_back(circle);

where Circle is a subclass of Obstacle.

My question is when should I call delete on the elements which are in the vector? I have heard each new should be balanced by a delete. Do I need to in the destructor loop through the vector and call delete on each element? Isn’t there a more elegant way?

Thanks

Answer 1

You have to call delete on the elements before you clear the vector, or before the vector goes out of scope iff the vector owns the objects pointed at. A more elegant solution is to have the vector hold smart pointers. The particular type of smart pointer should depend on the ownership policy.
For example, a vector owning the pointed-at objects should use C++11 std::unique_ptr:

std::vector<std::unique_ptr<Obstacle>> obstacles;

Of course, all of the above is under the assumption that you actually have strong reasons to use pointers. Often the best solution is the simplest ones: hold items by value:

std::vector<SomeType> things;

Note that this doesn’t apply in your case, where you are storing pointers to objects derived from a base class, since storing values of base type would result in object slicing.

Edit: One simple way to ensure the elements are deleted when the vector goes out of scope is to write a scope guard class:

template <typename CONTAINER>
struct PtrContainerGuard
{
  PtrContainerGuard(CONTAINER& container) : c_(container) {}
  ~PtrContainerGuard()
  {
    for (typename CONTAINER::iterator it = c_.begin(); it != c_.end(); ++it)
      delete (*it);
  }
private:
  CONTAINER& c_;

}

then

std::vector<Obstacle*> obstacles;
PtrContainerGuard<std::vector::Obstacle*> p(obstacles);