Question

Suppose we have the following:

class StringClass
{
public:
    ...
    void someProcessing( );
    ...
    StringClass& operator=(const StringClass& rtSide);
    ...
private:
    char *a;//Dynamic array for characters in the string
    int capacity;//size of dynamic array a
    int length;//Number of characters in a
};

StringClass& StringClass::operator=(const StringClass& rtSide)
{
    capacity = rtSide.capacity;
    length = rtSide.length;
    delete [] a;
    a = new char[capacity];

    for (int i = 0; i < length; i++)
       a[i] = rtSide.a[i];

    return *this;
}

My question is: why does this implementation of overloading the assignment operator cause problems when we try to assign an object to itself like:

StringClass s;
s = s;

The textbook I’m reading (Absolute C++) says that after delete [] a; “The pointer s.a is then undefined. The assignment operator has corrupted the object s and this run of the program is probably ruined.”

Why has the operator corrupted s? If we’re reinitalizing s.a right after we delete it, why does this cause such a problem in the program that we have to redefine the function as:

StringClass& StringClass::operator=(const StringClass& rtSide)
{
    if (this == &rtSide)
    //if the right side is the same as the left side
    {
        return *this;
    }
    else
    {
        capacity = rtSide.capacity;
        length = rtSide.length;
        delete [] a;
        a = new char[capacity];
        for (int i = 0; i < length; i++)
            a[i] = rtSide.a[i];

        return *this;
    }
}

Answer 1

If you are assigning an object to itself both a and rt.a point to the same string, so when you do delete [] a you are deleting both what a and rt.a point to; then you do reallocate it, but the data you were going to copy (on itself) in the loop has been lost in the delete.

In the loop now you will just copy whatever junk happens to be in the memory returned by new on itself.

By the way, even with the “safety net” of the self-assignment check that assignment operator isn’t completely ok (for instance, it’s not exception safe); the “safe” way to define the “big three” (copy constructor, assignment operator, destructor) is using the “copy and swap idiom“.