Copy Assignment Operator Design

This article starts from working code rather than from a definition. A Vector class manages a dynamic array of doubles. Two of its member functions do most of the work when one Vector is made from another: a copy constructor, which builds a new Vector from an existing one, and a copy assignment operator, which overwrites an existing Vector with the contents of another. Both functions copy elements and both allocate new memory, so they look alike on the page. The difference is in what already exists when each one runs, and that difference explains the order of operations in the copy assignment operator.

Before reading any function, fix the starting state in your mind. Suppose a Vector x already holds three elements, and a Vector y holds two different elements. Before the first line of the assignment runs, x owns an array of three values and its sz is 3. y owns its own separate two-value array and its sz is 2. Each Vector has its own elem pointer and its own sz. The trace that follows keeps asking one question at every line: which object is being read, and which object is being written?

After the assignment, x holds the two elements that came from y, and sz for x is 2. The y object is exactly as it was. The diagram shows the same pattern: x's storage and size change, while y's storage and size stay put. Notice that the arrays are not the same array after the assignment. x ends up with its own array, separate from y's.

The copy constructor performs two jobs. First, it allocates new memory for the copy. Second, it copies the elements from the original object. The member initializer list carries out the allocation. The expression elem{new double[a.sz]} requests an array with as many doubles as the original holds, and sz{a.sz} records the same size. The body of the constructor then runs a loop from zero up to sz, assigning each element of the original into the matching position of the new array.

Notice that the constructor only reads from the original. The parameter is a const reference, so the original object is never modified by the copy. Everything that changes during the operation belongs to the new object being built. Because the new object gets its own array from new, the copy and the original never share storage.

The target of copy assignment already exists and already owns an array of elements. That is the central difference from the copy constructor. The copy constructor creates a brand new object, so there is no old state to release. Copy assignment must release the state the existing object already owns, which means it must delete the old elements before it stores the new ones. The source describes two key facts: copy assignment allocates new memory for the copy, and it deletes old elements before assigning new ones.

The order of operations is the point to read closely. The function first allocates a new array p and copies every element of a into it. Only after that copy is complete does it call delete[] on the old elem array. Then it points elem at p, updates sz, and returns *this. Because the new data is fully built before the old data is released, the function never has to throw away its only copy of the values it still needs.

The same tracing approach applies to the copy constructor. Walk through the initializer list first, then the loop body, and at each step ask which object is being read and which is being written. In the copy constructor, a is only read, and every write goes into the new object. In copy assignment, a is still only read, but writes go into two places: the new array p, and then x's own members elem and sz.