C++ Vectors – When to Use Vector of Objects vs Vector of Pointers

c++

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.)

Best Answer

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.

Using a `shared_ptr`

Using a shared_ptr could declare your vector like this:

std::vector< boost::shared_ptr< ObjectBase > > object_list;

And use it like this:

typedef std::vector< boost::shared_ptr< ObjectBase > >::iterator ObjectIterator;

for ( ObjectIterator it = object_list.begin(); it != object_list.end(); it++ )
    (*it)->draw(view);

This would give you polymorphism and would be used just like it was a normal vector of pointers, but the shared_ptr would do the memory-management for you, destroying the object when the last shared_ptr referencing it is destroyed.

Note about C++11: In C++11 shared_ptr became part of the standard as std::shared_ptr, so Boost is no longer required for this approach. However, unless you really need shared ownership, it is recommended you use std::unique_ptr, which was newly introduced in C++11.

Using a `ptr_vector`

Using a ptr_vector you would do it like this:

boost::ptr_vector< ObjectBase > object_list;

And use it like this:

typedef boost::ptr_vector< ObjectBase >::iterator ObjectIterator;

for ( ObjectIterator it = object_list.begin(); it != object_list.end(); it++ )
    (*it)->draw(view);

This would again be used like a normal vector of pointers, but this time the ptr_vector manages the lifetime of your objects. The difference to the first approach is, that here your objects get destroyed when the vector gets destroyed, whereas above they may live longer than the container, if other shared_ptrs referencing them exist.

Using a `reference_wrapper`

Using a reference_wrapper you would declare it like this:

std::vector< boost::reference_wrapper< ObjectBase > > object_list;

And then use it like this:

typedef std::vector< boost::reference_wrapper< ObjectBase > >::iterator 
    ObjectIterator;

for ( ObjectIterator it = object_list.begin(); it != object_list.end(); it++ )
    it->draw(view);

Notice that you do not have to dereference the iterator first as in the above approaches. This does however only work if the lifetime of your objects is managed elsewhere and is guaranteed to be longer than that of the vector.

Note about C++11: reference_wrapper has also been standardized in C++11 and is now usable as std::reference_wrapper without Boost.

As pointed out in Maciej Hs answer, your first approach results in object slicing. In general you may want to look into iterators when using containers.

Best Answer

Related Solutions

C++ – Vector of Objects vs. Vector of Pointers to New Objects

Using a shared_ptr

Using a ptr_vector

Using a reference_wrapper

Related Question

Using a `shared_ptr`

Using a `ptr_vector`

Using a `reference_wrapper`