什么时候std :: shared_ptr释放它的对象？

Question

I'm on Ubuntu 14.04 using GCC 4.8.4 and I have code similar to the following:

std::shared_ptr<MyClass> my_shared_object = set elsewhere...
MyFunction(*my_shared_object);

Where MyFunction 's signature looks like this:

void MyFunction(const MyClass& my_object)

The full code can be found here

However, I am finding that my_object actually goes out of scope within the context of MyFunction . My thought was that the my_shared_object will only release its contents once it goes out of scope, meaning after the MyFunction has returned. I am not sure if I am either misunderstanding std::shared_ptr or if maybe this is a GCC bug.

I guess the question boils down to: when I dereference a std::shared_ptr, does that guarantee that the std::shared_ptr will persist as long as the dereference is being used?

Answer 1

Whatever is managed by a std::shared_ptr will be destroyed the moment there's no std::shared_ptr left asserting a claim, all other ways to refer to it are irrelevant.

And local variables are only destroyed upon leaving the respective scope. Dereferencing a std::shared_ptr does not modify it in any way.

Answer 2

std::shared_ptr doesn't know about your reference (or your reference doesn't know about the std::shared_ptr ) to the object being held, it's aware only of other std::shared_ptr s sharing the ownership of the same object. Therefore, as soon as the last std::shared_ptr goes out of scope, the object gets destructed and you end up with a dangling reference.

However, that should not be the case here and your std::shared_ptr should get properly destructed after the program flow leaves its scope, which I don't understand how, could happen before the call to MyFunction .

Answer 3

std::shared_ptr's maintain an internal reference count. This count corresponds to number of objects sharing the object. Everytime a shared_ptr goes out of scope, the internal reference count is decremented. when the internal reference count falls to zero, the memory is de-allocated.