Question

I have a collection of polymorphic objects, all derived from my Animal class: Cat, Dog, and MonkeyFish.

My usual mode of operation is to store these objects in a vector of Animal pointers, like so:

std::vector< Animal * > my_vector;

 my_vector.push_back( new Animal_Cat() ); my_vector.push_back( new Animal_Dog() ); my_vector.push_back( new Animal_MonkeyFish() ); 

And life is great…or is it?

I’ve recently been told that I should really try to avoid allocating memory in this fashion, because it makes memory management a chore. When I need to destroy my_vector, I have to iterate through all the elements and delete everything.

I don’t think that I can store a vector of references (I might be wrong about this), so it seems like storing a vector of Animal objects is my only alternative.

When should I choose to use a vector of pointers versus a vector of objects? In general, which method is preferable? (I would like to reduce object copying as much as possible.)

Answer 1

You should use a vector of objects whenever possible; but in your case it isn’t possible.

Containers of pointers let you avoid the slicing problem. But then you have to call delete on each element, like you are doing. That’s annoying but possible. Unfortunately there are cases (when an exception is thrown) where you can’t be sure that delete is properly called, and you end up with a memory leak.

The main solution is to use a smart pointer. Pre-C++11 comes with auto_ptr, but that cannot be used in a standard container. C++11 has std::unique_ptr and std::shared_ptr which are designed to be usable in containers (I prefer std::unique_ptr unless I really need reference counting). If you can’t use C++11, the best solution is Boost smart pointers.