C++ method parameter passed by reference - memory question

Question

Assume,

void proc(CString& str)
{
  str = "123";
}

void runningMethod()
{
  CString str="ABC";
  proc(str);
}

I understand that at the exit of runningMethod str will be deallocated automatically; in this case, how does C++ delete the old data ("ABC")?

Thanks,

Gil.

Answer 1

"ABC" was overwritten when you said = "123".

Internally, a string is an array of characters. At start, it made a new buffer that contained {'A', 'B', 'C', '\0'}. When you assigned, it just wrote '1' over the 'A', and so on.

When it destructed, it deleted the buffer.

Answer 2

The exact details depend on the implementation of CString, but the important bit is that you don't have to worry about allocation and deallocation now that the class takes care of it for you.

Answer 3

The same happens as if you'd write:

CString foo = "ABC";
foo = "123";

Answer 4

In most cases when you do your assignment in proc() "ABC" will be freed. This is usually done in overloaded operator method. For example here you have example how such overload looks like.

String& String::operator= (const String& other)
{
        char* otherdata = other.data;
        char* olddata = data;
        if (otherdata != 0)
        {
                data = new char[other.length+1];
                length = other.length;
                memcpy(data,otherdata,other.length+1);
        }
        else
        {
                data = 0;
                length = 0;
        }
        if (olddata != 0)
        {
                delete[] olddata;
        }
    return *this;
}