boost::shared_ptr standard container

Question

Assume I have a class foo, and wish to use a std::map to store some boost::shared_ptrs, e.g.:

class foo;

typedef boost::shared_ptr<foo> foo_sp;
typeded std::map<int, foo_sp> foo_sp_map;

foo_sp_map m;

If I add a new foo_sp to the map but the key used already exists, will the existing entry be deleted? For example:

foo_sp_map m;

void func1()
{
    foo_sp p(new foo);
    m[0] = p;
}

void func2()
{
    foo_sp p2(new foo);
    m[0] = p2;
}

Will the original pointer (p) be freed when it is replaced by p2? I'm pretty sure it will be, but I thought it was worth asking/sharing.

Answer 1

First off, your question title says boost::auto_ptr, but you actually mean boost::shared_ptr

And yes, the original pointer will be freed (if there are no further shared references to it).

Answer 2

It depends on what happens in your ... section

Your container class contains copies of instances of foo_sp, when you execute m[0] = p2; the copy of p that was originally in that place goes out of scope. At that time it will be deleted if there are no other foo_sp refers to it.

If the copy that was declared in the second line foo_sp p(new foo); is still around then the memory will not be deallocated. The entry will be delete once all references to it have been removed.

Answer 3

Since stackoverflow won't allow me to comment, I'll just answer. :/

I don't see "p" going out of scope, so the object pointed to by it will not be freed. "p" will still point to it.