How using a smart pointer in C++ helps in below example

Question

I was reading about smart pointers in C++ and saw this example given as how smart pointers handle "dangling pointer" problem if normal pointers are used. P.S. I know auto_ptr is deprecated by C++ 2011 but it still has unique_ptr or some such equivalent of it.

Dangling pointers. A common pitfall of regular pointers is the dangling pointer: a pointer that points to an object that is already deleted. The following code(jsut for example purpose) illustrates this situation:

    MyClass* p(new MyClass);//Assume we have a MyClass definition available
    MyClass* q = p;
    delete p;
    p->DoSomething();   
    p = NULL;           // p is not dangling anymore
    q->DoSomething();   // Don't.. q is still dangling!

Using auto_ptr, this is solved by setting its pointer to NULL when it is copied (Copy constructor implemented as below):

template <class T>
auto_ptr<T>& auto_ptr<T>::operator=(auto_ptr<T>& rhs)
{
    if (this != &rhs) {
        delete ptr;
        ptr = rhs.ptr;
        rhs.ptr = NULL;
    }
    return *this;
}

And now if we have the same code using auto_ptr as below:

auto_ptr<MyClass> p(new MyClass);
auto_ptr<MyClass> q = p;
delete p;
p->DoSomething();   
p = NULL;           
q->DoSomething();

I get the logic in the aqbove copy constructor but how does making the rhs.ptr = NULL help. I mean if one dereferences this pointer later (q in above code example), it would crash as it is made NULL by the smart pointer copy constructor.

Where as what would have happened if it was a normal pointer and we would have dereferenced a dangling pointer? Some undefined behavior maybe. But how does using auto_ptr help

Your first example is already undefined behavior before anything is dangling. Try to understand regular pointers first. — pmr
@pmr - Would you please write a line explaining how is that. — goldenmean
You new up one object. Point with two different pointers at it. delete it and then call a method on it. — pmr
I don't know whether you've miscopied or what, but the initial examples are broken. The initial one accesses through a dangling pointer, the example code for std::auto_ptr isn't a legal implementation (and would fail on self-assignment if it were), and the last example does a delete on an auto_ptr, which shouldn't even compile. — James Kanze

Mike Seymour Mike Seymour · Accepted Answer · 2012-02-27T17:09:36

Smart pointers won't necessarily protect you if you dereference them without checking them first; what they give you is a guarantee that you can check whether they are valid before dereferencing.

The problem with a dangling pointer is that it doesn't point to anything valid, but there's no way to tell:

Thing * p = new Thing;
Thing * q = p;

if (p) p->DoSomething(); // OK: checks p, calls function
if (q) q->DoSomething(); // OK: checks q, calls function

delete p;
p = nullptr;

if (p) p->DoSomething(); // OK: checks p, does nothing
if (q) q->DoSomething(); // BOOM! Undefined behaviour

With a smart pointer, you'll never have that situation; either the pointer is valid, or you can tell that it's invalid before dereferencing:

auto_ptr<Thing> p(new Thing);
auto_ptr<Thing> q = p;

if (p) p->DoSomething(); // OK: checks p, does nothing
if (q) q->DoSomething(); // OK: checks q, calls function

p.reset(); // does nothing

if (p) p->DoSomething(); // OK: checks p, does nothing
if (q) q->DoSomething(); // OK: checks q, calls function

q.reset(); // deletes the object

if (p) p->DoSomething(); // OK: checks p, does nothing
if (q) q->DoSomething(); // OK: checks q, does nothing

How using a smart pointer in C++ helps in below example

5 Answers