Effective C++ Item 11 handle assignment to self

Question

I am reading this book and I do not understand the difference between two pieces of code.

class Bitmap{...};
class Widget
{
    ...
private:
    Bitmap* m_pb;
};

Widget& Widget::operator=(const Widget& rhs)
    {
        if (this == &rhs)
        {
            return *this;  // if a self-assignment, do nothing
        }
        delete pb;
        pb = new Bitmap(*rhs.m_pb);
        return *this;
    }

Mr. Meyers says:

if the "new Bitmap" expression yields an exception, the Widget will end up holding a pointer to a deleted Bitmap.

Does it mean that the pd pointer points to NULL?

Widget& Widget::operator=(const Widget& rhs)
{
    Bitmap* temp = pb;
    pb = new Bitmap(*rhs.pb);
    delete temp;
    return *this;
}

Mr. Meyers says:

Now, if "new Bitmap" throws an exception, pb pointer remains unchanged.

As far as I know, temp pointer points to the same memory address as pb pointer. If the "new" throws an exception, pb will point to NULL and the next sentence will delete the Bitmap. Is that correct? I do not see the difference between these implementations.

Thanks in advance.

Answer 1

The fact that you assign temp to the same memory location as pb doesn't influence pb in any manner. In the next line, if Bitmap constructor will throw an exception the control won't reach the assignment part, thus pb will remain unchanged.

Answer 2

Does it mean that the pd pointer points to NULL?

No. Yes. Maybe. The pointer has been deleted, you can't rely on what it does or does not point to, so you're on the fast-track to undefined behaviour.

As far as I know, temp pointer points to the same memory address as pb pointer. If the "new" throws an exception, pb will point to NULL and the next sentence will delete the Bitmap. Is that correct?

If new throws here, pb will be in the same state that it was before and the next expression will not be executed.

I do not see the difference between these implementations.

In the first snippet, pb points to a deleted pointer if new throws. In the second snippet, pb points to the same valid object it used to if new throws.