一一销毁单个 shared_ptr

Question

I am attempting to destruct a shared_ptr one-by-one, yet when I destruct the last pointer, the use_count() goes nuts. Observe my code:

#include <iostream>
#include <memory>


int main() {

    int * val = new int(5);
    std::shared_ptr<int> myPtr = std::make_shared<int>(*val);

    myPtr.~__shared_ptr();

}

Will produce the following output in the debugger:

myPtr value: 5  myPtr.use_count():8787448 // Or some other large int

I was hoping on the final destruction it would set the use_count() to 0 and deallocate the memory for the integer. It appears none of this is happening.

I could if() statement this when the use_count() == 1, but this seems very inelegant. Does anyone know of another solution?

Answer 1

I am attempting to destruct a shared_ptr one-by-one,

I have no idea what that means, but ...

myPtr.~__shared_ptr();

Never, ever, ever do this.

You are running the destructor for an automatic object, ie one that lives on the stack and will be destroyed automatically by the compiler when it goes out of scope. By destroying it manually you cause it to be destroyed twice. You cannot end an object's lifetime twice, it is not James Bond, it only lives once.

Destroying the same object twice is undefined behaviour. That means weird things can happen. Asking why you get weird results from a program with undefined behaviour is a waste of time. Weird things happen when you have undefined behaviour because you have undefined behaviour . Anything can happen. You should be thankful it's only weird, and not catastrophic.

The standard specifically points out this exact scenario is undefined behaviour, in 12.4 [class.dtor]:

Once a destructor is invoked for an object, the object no longer exists; the behavior is undefined if the destructor is invoked for an object whose lifetime has ended (3.8). [Example: if the destructor for an automatic object is explicitly invoked, and the block is subsequently left in a manner that would ordinarily invoke implicit destruction of the object, the behavior is undefined. — end example]

Even worse, you are running the destructor for a base class of myPtr so you are only destroying part of the object. That means you have an object where part of it is dead and part of it is alive, and then at the end of the scope part of it gets killed again. Under no circumstances can that ever be the right thing to do. Ever.

I was hoping on the final destruction it would set the use_count() to 0 and deallocate the memory for the integer. It appears none of this is happening.

Your conclusion is wrong. It probably is happening, but if the object is destroyed and the memory is deallocated then trying to look at it produces nonsense results. You can't ask a zombie what its name is, it will reply "BRAINZZZZ!" instead of telling you anything useful. And eat your brains. Now you are dead. Don't play with zombies.

Also, as Neil Kirk comments above, this is also wrong:

int * val = new int(5);
std::shared_ptr<int> myPtr = std::make_shared<int>(*val);

You create an int on the heap, then you create copy of it on the heap that will be managed by a shared_ptr . The shared_ptr owns an int which has the same value as *val but nothing owns val so that will be a memory leak. You probably meant to do either this:

int * val = new int(5);
std::shared_ptr<int> myPtr(val);

or more likely this:

int val = 5;
std::shared_ptr<int> myPtr = std::make_shared<int>(val);

Answer 2

I think I figured out what you are after. You want to detect when the use count of the shared object is zero.

The way this is done is using a std::weak_ptr that is designed to work with the std::shared_ptr so you can keep track of whether or not the object has been destroyed.

Here:

#include <memory>
#include <iomanip>
#include <iostream>

int main()
{
    // weak_ptr is only convertable to a shared_ptr if the shared_ptr
    // usage count is > 0
    std::weak_ptr<int> wp;

    {
        std::shared_ptr<int> ptr = std::make_shared<int>(5);
        wp = ptr; // link weak_ptr to shared_ptr

        if(auto sp = wp.lock()) // try to convert weak_ptr to shared_ptr
        {
            // if we get here use_count was > 0
            std::cout << "Before: use count > 0: "
                << std::boolalpha << (sp.use_count() > 0) << '\n';
        }
        else
        {
            // if we get here use_count was == 0
            std::cout << "Before: Destroyed\n";
        }
        // ptr goes out of scope here
    }

    if(auto sp = wp.lock()) // try to convert weak_ptr to shared_ptr
    {
        // if we get here use_count was > 0
        std::cout << "After: use count > 0: "
            << std::boolalpha << (sp.use_count() > 0) << '\n';
    }
    else
    {
        // if we get here use_count was == 0
        std::cout << "After: Destroyed\n";
    }
}

Basically, if the linked std::shared_ptr still holds a reference to the object then the associated std::weak_ptr can be converted to a std::shared_ptr using std::weak_ptr::lock . If that fails then the associated std::shared_ptr is no longer pointing at the shared object - it has been destroyed.