Using the pointer returned from a std::shared_ptr.get() function to delete an object?

Question

int main(int argc, char *argv[])
{
    auto sp = std::make_shared<int>();
    auto p = sp.get();
    delete p; //here
    std::cout << *sp << std::endl;

    return 0;
}

I was hoping that the object managed by the shared_ptr sp will be deleted by the statement commented "here" but the object remains intact and is printed in the output statement.

• Is this not working because I didn't create the object managed by the shared_ptr explicitly with the new keyword (because every new statement must have a corresponding delete statement and therefore every delete statement, an earlier corresponding new keyword?)?
• And does this mean that pointed objects managed by shared_ptrs, created from the make_shared function are destroyed only by the shared_ptrs themselves?

Answer 1

The shared_ptr doesn't know you delete the pointer you got from .get(). So when the shared_ptr itself is destroyed it will also try to delete the object - leading to a double delete which is undefined behaviour. Additionally, dereferencing a pointer to a deleted object is also UB.

delete marks the memory occupied by the object as "free to be re-used" and calls the objects destructor. After delete you are not allowed (under pain of invoking UB) to ever access the object again.

Your program is simply invalid and anything the compiler may generate is allowed.

Answer 2

The way to "manage" the memory associated with a shared_ptr is to use C++ scoping, often referred to RAII (Resource Acquisition Is Initialization).

For your code:

int main(int argc, char *argv[])
{
    {
       auto sp = std::make_shared<int>();
       std::cout << *sp << std::endl;
    }
    // memory is now delete'd because "sp" is out-of-scope

    return 0;
}

With shared_ptr things can actually be (quite a bit) more complicated than that as multiple shared_ptrs can be pointing to the same memory; only when the last one is gone is the memory deleted.

Your preference should be to use std::unique_ptr until you really need shared_ptr.

Answer 3

Firstly, if you do this your object will be deleted twice, and you'll crash if you're lucky.

Second, just because something has been deleted doesn't mean it's underlying representation is guaranteed to be invalid. You can have a situation where the memory is freed, but nothing has yet come around to overwrite what was there before.