Visual walkthrough — Copy constructor and copy assignment — Rule of Three

We will use exactly one running example: a tiny class that owns a piece of heap memory holding a word. Everything else — pointers, new, delete — we build from zero, right where we need it.

Step 1 — What "owns a resource" even means (picture the box and the note)

WHAT. An object is just a little bundle of variables sitting somewhere in memory. When one of those variables is a pointer — a variable whose value is an address, a house number telling you where some other memory lives — we say the object points at a resource.

WHY this matters. The pointer variable and the memory it points at are two different things living in two different places. The pointer sits inside the object (cheap, small). The memory it points at was carved out of the heap — a big pool of memory you request at run time with the keyword new and must hand back with delete. See Dynamic memory new and delete.

PICTURE. In the figure, the small blue square is the object. Inside it is a variable data holding an arrow (the address). The orange box far away is the actual heap buffer holding the characters c a t \0. The arrow is the "note with the box's address"; the orange box is the "toy box".

The whole drama that follows is one question: when we copy the object, what happens to that arrow?

Step 2 — What the compiler does for free: it photocopies the arrow

WHAT. If you write no copy code, the compiler generates a copy that goes member by member. For a pointer member, "copy the member" means copy the address value — the arrow — not the box it points to. This is a shallow copy (see Deep vs shallow copy).

WHY it does this. The compiler has no idea data is owned memory. To it, data is just a number. Copying a number is copying a number. It cannot guess that this number is a claim of ownership.

PICTURE. Object a already points at the orange buffer. We write b = a (a copy). The compiler duplicates the arrow: now b.data holds the same address. Two blue squares, two arrows, one orange box. Both arrows land on the same buffer — this is called aliasing.

$b.\text{data}=a.\text{data}$

• $b.\text{data}$ — the pointer inside the new object b.
• $=$ — plain value copy of the address.
• $a.\text{data}$ — the same address a already holds. After this line, both equal the same house number.

Notice: no new ran. No second box was ever built.

Step 3 — Why the shallow copy is a time bomb: the double free

WHAT. Every object that owns a resource has a destructor ~T() that runs delete[] data when the object dies. With two objects sharing one buffer, that destructor runs twice on the same address.

WHY this is fatal. delete[] tells the heap "this box is free again — reuse it." Saying that once is correct. Saying it twice about the same box is undefined behaviour: the second delete[] frees memory that no longer belongs to anyone, corrupting the heap's bookkeeping. In practice: a crash.

PICTURE. Watch the timeline. Object b goes out of scope first → delete[] frees the orange box (now shown gray = returned to the pool). Object a is now dangling: its arrow points at freed memory (red, broken arrow). When a dies, delete[] runs again on the already-freed box → 💥.

Step 4 — The fix, seen: a deep copy builds a second box

WHAT. A deep copy does what the compiler wouldn't: it calls new to allocate a fresh buffer, then copies the characters into it — not the address. That is the whole job of the copy constructor MyString(const MyString& other).

WHY a fresh allocation. So the two objects own independent boxes. Now each destructor frees its own box exactly once — no sharing, no double free, no aliasing.

PICTURE. b is being born from a. First new char[len+1] carves out a second orange box. Then strcpy walks the characters c a t \0 from a's box into b's box. Two objects, two arrows, two boxes — the arrows never cross.

$b.\text{data}=\text{new char}[\underset{\text{chars}}{\underbrace{\text{len}}}+\underset{\text{’0’}}{\underbrace{1}}]$

• $b.\text{data}$ — pointer in the new object, now pointing at brand-new memory.
• $\text{new char}[\dots ]$ — request a fresh block from the heap; returns its address.
• $\text{len}+1$ — room for every character plus one for the \0 terminator that marks the string's end.

Then std::strcpy(b.data, other.data) copies the contents, character by character, until it copies the \0.

Step 5 — Assignment is different: there's an OLD box to throw away first

WHAT. The copy constructor built a fresh object with no prior buffer. The copy assignment operator T& operator=(const T& other) overwrites an object that already owns a box. So before allocating a new one, it must delete[] the old one — otherwise that old box is orphaned forever: a memory leak.

WHY the difference. Birth vs rebirth. A newborn has empty hands. A living object already clutches a box; to hold a new box it must first let go of the old, or that old box floats away unreachable.

PICTURE. Left panel: b owns box "elephant", a owns box "cat". We run b = a. Frame 1: delete[] b.data returns the "elephant" box to the pool (gray). Frame 2: new + strcpy gives b a fresh "cat" box. a is untouched throughout.

$\underset{\text{free old box}}{\underbrace{\text{delete[] data;}}}\to \underset{\text{grab new box}}{\underbrace{\text{data = new char[len+1];}}}\to \underset{\text{copy contents}}{\underbrace{\text{strcpy(data, other.data);}}}$

The order is sacred: free, then allocate, then copy. See Self-assignment and exception safety.

Step 6 — The degenerate case: a = a (self-assignment)

WHAT. What if the object being assigned to is the same object being copied from? Directly (a = a) or hidden (arr[i] = arr[j] when i == j, or two references to one object). This is the self-assignment edge case, and it destroys the naive operator= from Step 5.

WHY it breaks. Follow the order literally. Step 1 was delete[] data — but if this is &other, then other.data is the box we just freed! Step 3, strcpy(data, other.data), then copies from freed, garbage memory into itself. Corruption.

PICTURE. One object, one box. The naive code runs delete[] on the box (gray, gone). Then it tries to strcpy from that same freed box — the red arrow points into rubble. The output is garbage.

The fix is one guard line at the very top:

$\text{if (this == \&other) return *this;}$

• $\text{this}$ — the address of the object being assigned to.
• $\text{\&other}$ — the address of the source object.
• If they are equal, both arrows point at the same object → do nothing, return early, keep the box intact.

Step 7 — The elegant escape: copy-and-swap handles every case at once

WHAT. Instead of hand-writing free/allocate/copy, take the parameter by value (which quietly calls the copy constructor from Step 4), then swap the guts. The overloaded operator= becomes three tiny lines.

WHY it wins. All allocation happens before we touch *this — inside making the by-value copy. If new throws, *this is still intact (this is exception safety). Self-assignment is automatically fine: you copy first, swap second, and the old guts die harmlessly with the parameter.

PICTURE. Three frames: (1) the by-value parameter other is a fresh deep copy of the source; (2) std::swap exchanges the arrows of *this and other — now *this holds the new box, other holds the old box; (3) other goes out of scope and its destructor frees the old box automatically. No manual delete, no self-check needed.

MyString& operator=(MyString other) {  // by value → copy already made
    std::swap(data, other.data);       // *this now owns the new box
    std::swap(len,  other.len);
    return *this;                      // 'other' (old box) dies → freed
}

This foreshadows Move semantics and Rule of Five and Rule of Zero and smart pointers, where the compiler-generated members become safe again because members like std::string already deep-copy themselves.

The one-picture summary

Three life-events, one resource. Birth-by-copy (constructor) builds a fresh box. Rebirth-by-copy (assignment) frees the old box, then builds a fresh one, guarding self-assignment. Death (destructor) frees the box once. All three exist for the same reason: manual ownership of one heap box. Miss any one, and you get a double free, a leak, or corrupted garbage.

Parent: Copy constructor and copy assignment — Rule of Three