copy assignment operator clarification

Question

Im writing a copy assignment operator for a class I've created and I'm using a previous post as a guide: What is The Rule of Three?

Im a bit confused on one aspect of this person's explanation.

Here is their class:

class person
{
    char* name;
    int age;
};

Here is the copy assignment operator definition that I am using as a reference (there are at least 2 offered):

// 2. copy assignment operator
person& operator=(const person& that)
{
    char* local_name = new char[strlen(that.name) + 1];
    // If the above statement throws,
    // the object is still in the same state as before.
    // None of the following statements will throw an exception :)
    strcpy(local_name, that.name);
    delete[] name;
    name = local_name;
    age = that.age;
    return *this;
}

What I'm finding confusing is, why are they including the line delete[] name;?

Here is the other example they provide:

person& operator=(const person& that)
{
    if (this != &that)
    {
        delete[] name;
        // This is a dangerous point in the flow of execution!
        // We have temporarily invalidated the class invariants,
        // and the next statement might throw an exception,
        // leaving the object in an invalid state :(
        name = new char[strlen(that.name) + 1];
        strcpy(name, that.name);
        age = that.age;
    }
    return *this;
}

I immediately shied away from this one because I couldn't understand why the function checks if(this != &that) and then runs delete (delete[] name;) on an array that doesn't seem to have been generated yet. When the assignment operator is invoked, is the regular constructor called immediately before the copy assignment operator function is called? Therefore meaning that we must delete the array that was generated by the classes constructor because it can only be full of junk data?

Why can't I just write: name = that.name or

name = new char[that.name.size()];
for (int i = 0; i < that.name.size(); i++)`
{
  name[i] = that.name[i]
}

This is probably really basic and I should just implement what the post suggests but my actual use-case involves an array of structs with multiple members and so Im just having a little bit of a difficulty understanding what exactly I need to do.

I realize there are like 2.5 questions here. Any insight would be appreciated.

This is my first time implementing custom copy constructors and copy assignment operators and Im sure it will seem easy after I've done it a few times.

Thanks in advance.

Answer 1

All of this is needed to make sure that memory is managed correctly.

If I understand correctly, you need an answer to when is operator= actually called?
Well, operator= is always called when two valid objects exist. One of them is being assigned to, and second one is source of data. After this operation, both object must still remain valid.

This means than inside operator= you have this object with memory allocated for a string (which was allocated in one of the contrusctors) and that object, also with memory allocated for another string.

What I'm finding confusing is, why are they including the line delete[] name;?

We have to first clean up memory which is currently residing in this object, or else we would lose this pointer after assigning new momry to it.

When the assignment operator is invoked, is the regular constructor called immediately before the copy assignment operator function is called?

No. The object already exists, that's why operator= is called (and not a copy constructor).

Therefore meaning that we must delete the array that was generated by the classes constructor because it can only be full of junk data?

It is full of valid data. Your object was contructed, it has some data in it, and then you assign something else to this object.

---

Addendum: When is copy contructor called and when is operator= called? (see this question for more detailed information):

class A{};

int main()
{
    A a1; //default constructor 
    A a2 = a1; //copy-constructor, not assignment operator! New object is needed

    A a3; 
    a3 = a1; //we have valid and existing object on the left side, assignment operator is used
}

Answer 2

What I'm finding confusing is, why are they including the line delete[] name;?

When using new and new[] to manage memory, the rule is thumb is that they should have a matching delete or delete[]. Presumably, name was previously allocated with new[] (either in the constructor or by a previous assignment), so before reassigning it on the next line with name = local_name;, we need to delete[] it.

I couldn't understand why the function checks if(this != &that)

This check is a sanity check. If you assign an object to itself, then there is no need to do anything. In fact, it could cause problems because if you delete[] name; when this points to the same object as that references, then you can no longer copy that.name because its memory has been freed.

Why can't I just write: name = that.name or

This will make name in two different instances point to the same memory. In some cases, such shared memory is not only useful but desired. However, you have to be careful because if one of the instances executes delete[] on its name then name in the other instance is no longer valid.

Answer 3

Let's start from the question about this code snippet.

name = new char[that.name.size()];
for (int i = 0; i < that.name.size(); i++)`
{
  name[i] = that.name[i]
}

The data member name has the type char *. That is it is a pointer. Neither pointers nor characters pointed to by pointers have member functions like size.

So this code snippet is invalid and will not compile.

You could use such an approach like this

name = that.name;

if the data member had the type std::string.

Why can't I just write: name = that.name

In this case two objects of the class will contain pointers that point to the same memory extent. So if one object will be deleted then the pointer of other object will be invalid and using it to delete the allocated memory results in undefined behavior.

When the assignment operator is invoked, is the regular constructor called immediately before the copy assignment operator function is called?

The copy assignment operator may be applied only for already constructed object. That is an object of the class must already to exist and the used constructor shall initialize its data member name either by nullptr or by the address of allocated memory.

I immediately shied away from this one because I couldn't understand why the function checks if(this != &that)

This check allows to avoid self-assignment of an object. That is in the case when an object is assigned to itself the code of allocating and deleting memory will be redundant.

What I'm finding confusing is, why are they including the line delete[] name;?

Because the object was already constructed and its data member name can point to allocated memory that contains a string for name.

Taking all what was said into account the copy assignment operator can look like

person& operator =( const person &that )
{
    if ( this != &that )
    {
        char *local_name = new char[strlen(that.name) + 1];
        // If the above statement throws,
        // the object is still in the same state as before.
        // None of the following statements will throw an exception :)
        strcpy(local_name, that.name);
        delete[] name;
        name = local_name;
        age = that.age;
    }

    return *this;
}