Question

I am looking for a way to insert multiple objects of type A inside a container object, without making copies of each A object during insertion. One way would be to pass the A objects by reference to the container, but, unfortunately, as far as I’ve read, the STL containers only accept passing objects by value for insertions (for many good reasons). Normally, this would not be a problem, but in my case, I DO NOT want the copy constructor to be called and the original object to get destroyed, because A is a wrapper for a C library, with some C-style pointers to structs inside, which will get deleted along with the original object…

I only require a container that can return one of it’s objects, given a particular index, and store a certain number of items which is determined at runtime, so I thought that maybe I could write my own container class, but I have no idea how to do this properly.

Another approach would be to store pointers to A inside the container, but since I don’t have a lot of knowledge on this subject, what would be a proper way to insert pointers to objects in an STL container? For example this:

std::vector<A *> myVector;
for (unsigned int i = 0; i < n; ++i)
{
    A *myObj = new myObj();
    myVector.pushBack(myObj);
}

might work, but I’m not sure how to handle it properly and how to dispose of it in a clean way. Should I rely solely on the destructor of the class which contains myVector as a member to dispose of it? What happens if this destructor throws an exception while deleting one of the contained objects?

Also, some people suggest using stuff like shared_ptr or auto_ptr or unique_ptr, but I am getting confused with so many options. Which one would be the best choice for my scenario?

Answer 1

In C++11, you can construct container elements in place using emplace functions, avoiding the costs and hassle of managing a container of pointers to allocated objects:

std::vector<A> myVector;
for (unsigned int i = 0; i < n; ++i)
{
    myVector.emplace_back();
}

If the objects’ constructor takes arguments, then pass them to the emplace function, which will forward them.

However, objects can only be stored in a vector if they are either copyable or movable, since they have to be moved when the vector’s storage is reallocated. You might consider making your objects movable, transferring ownership of the managed resources, or using a container like deque or list that doesn’t move objects as it grows.

UPDATE: Since this won’t work on your compiler, the best option is probably std::unique_ptr – that has no overhead compared to a normal pointer, will automatically delete the objects when erased from the vector, and allows you to move ownership out of the vector if you want.

If that’s not available, then std::shared_ptr (or std::tr1::shared_ptr or boost::shared_ptr, if that’s not available) will also give you automatic deletion, for a (probably small) cost in efficiency.

Whatever you do, don’t try to store std::auto_ptr in a standard container. It’s destructive copying behaviour makes it easy to accidentally delete the objects when you don’t expect it.

If none of these are available, then use a pointer as in your example, and make sure you remember to delete the objects once you’ve finished with them.