Copy Assignment

Suppose you have a Vector called v1 that holds several elements, and you write Vector v2 = v1;. What should v2 contain afterward? The answer depends on how the class copies itself. A simple class with plain fields may only need its fields copied one by one. A class that owns a dynamically allocated array is different: the new object needs its own array, and the values must be copied into that array. This article follows the Vector class through that situation, first for creating a new object and then for assigning to an object that already exists.

Before reading any implementation, form a prediction. What do you expect v2 to share with v1: the same array, or a separate array holding the same values? Keep that guess in mind as you trace the code.

The copy constructor is the code that runs when a new Vector is created from an existing Vector. In the declaration Vector v2 = v1;, the new object v2 is constructed as a copy of v1. The source frames this with the example v2=v1: the constructor builds a new object, and it does not change an object that already exists.

The constructor takes a const reference to the source object, which is named a in the source's form. A const reference lets the constructor read the source without changing it. The member initializer list allocates the array and records the size. The body then copies the elements one at a time. Allocation happens first, so the body has a place to put each value.

The important property of this constructor is that the new object does not borrow the storage of the original. Allocating new memory and copying the values into it is what makes the copy a deep copy. The new object has its own copy of the original object's data. Changing the elements of one object does not change the elements of the other.

The values 1, 2, 3 in the diagram are illustrative and are not taken from the source. The key point is that each Vector object points to its own array of elements. Each object owns its buffer, so writing into one buffer leaves the other buffer as it was.

A copy constructor handles the case where the new object does not exist yet. Copy assignment handles a different case: assigning one existing object to another existing object of the same class. The source describes copy assignment as copying contents into an object that already exists, and it says this operation is needed in addition to a copy constructor.

The two operations do similar copying work but at different moments. The constructor runs as part of creating an object. Assignment runs later, when the destination already holds its own elements. That destination must release those old elements, which is why assignment does more than the constructor does.

Inside a member function, the name this refers to the object on which the function was called. The source states that the destination is the object for which operator= is called, and this points to that object. The source is the object passed in as the parameter a. Inside operator=, the destination is therefore reached through this, and the source is reached through a.

The operator returns a reference to the destination. The source describes this as returning the current object by reference, through the expression that dereferences this. The return type is a reference to the destination, not the source. Checking the return expression is one of the steps the source recommends when tracing an unexpected result.

The operator must allocate storage for the source elements, copy them, and make the destination use that storage. A copy of the count alone is not enough, because the destination's old elements must be replaced by copies of the source's elements.

In the diagram, the old buffer holding 7 and 8 is the resource released by the delete[] step. The source's buffer is only read, so it is unchanged. The values 7, 8, 1, 2, 3 are illustrative and are not taken from the source.

The source and destination may be the same object, as in v = v;. In that case, the parameter a and this refer to the same Vector. The order of steps decides whether the data survives. Consider the order the source describes: copy first, then delete the destination's old elements.

Follow the flowchart with v = v. The new buffer is allocated and filled with copies of v's current elements before the old buffer is deleted. When the old buffer is deleted, the copies already exist in the new buffer, so no data is lost. If the old buffer were deleted first, the loop would read from memory that had already been released, and the data would be destroyed before it was copied.