Question

I need a collection in which i can store heap-allocated objects having virtual functions.

I known about boost::shared_ptr, std::unique_ptr (C++11) and boost::ptr_(vector|list|map), but they doesn’t solve duplicate pointer problem.

Just to describe a problem – i have a function which accepts heap-allocated pointer and stores it for future use:

void SomeClass::add(T* ptr)
{
  _list.push_back(ptr);
}

But if i call add twice with same parameter ptr – _list will contain two pointers to same object and when _list is destructed multiple deletion of same object will occur.

If _list will count pointer which he stores and uses them at deletion time then this problem will be solved and objects will not be deleted multiple times.

So the question is:

Does somebody knows some library with collections (vector,list,map in essence) of pointer with auto-delete on destruction and support of reference counting?

Or maybe i can solve this problem using some other technique?

Update:

I need support of duplicate pointers. So i can’t use std::set.

As Kerrek SB and Grizzly mentioned – it is a bad idea to use raw pointers in general and suggests to use std::make_shared and forget about instantiation via new. But this is responsibility of client-side code – not the class which i designs. Even if i change add signature (and _list container of course) to

void SomeClass::add(std::shared_ptr<T> ptr)
{
   _list.push_back(ptr);
}

then somebody (who doesn’t know about std::make_shared) still can write this:

SomeClass instance;
T* ptr = new T();
instance.add(ptr);
instance.add(ptr);

So this is not a full solution which i wait, but useful if you write code alone.

Update 2:

As an alternative solution i found a clonning (using generated copy constructor). I mean that i can change my add function like this:

template <typename R>
void SomeClass::add(const R& ref)
{
  _list.push_back(new R(ref));
}

this will allow virtual method (R – class which extends some base class (interface)) calls and disallow duplicate pointers. But this solution has an overhead for clone.

Answer 1

Yes: std::list<std::shared_ptr<T>>.

The shared pointer is avaiable from <memory>, or on older platforms from <tr1/memory>, or from Boost’s <boost/shared_ptr.hpp>. You won’t need to delete anything manually, as the shared pointer takes care of this itself. You will however need to keep all your heap pointers inside a shared pointer right from the start:

std::shared_ptr<T> p(new T);    // legacy
auto p = std::make_shared<T>(); // better

If you another shared pointer to the same object, make a copy of the shared pointer (rather than construct a new shared pointer from the underlying raw pointer): auto q = p;

The moral here is: If you’re using naked pointers, something is wrong.