Copy constructor and copy assignment — Rule of Three

WHAT are these three things?

The key distinction:

MyString a = b;   // copy CONSTRUCTOR (a is being born)
MyString c;
c = b;            // copy ASSIGNMENT  (c already exists)

WHY does the compiler-generated version break? (Shallow vs Deep)

Figure — Copy constructor and copy assignment — Rule of Three

Shallow copy aftermath:

a.data ──┐
         ├──► [ "hi\0" ]      one buffer, two owners
b.data ──┘

When a and b both destruct: delete[] (same ptr) runs twice → undefined behavior. Also, writing through a silently corrupts b (aliasing).

HOW to write them — deriving a safe `MyString` from scratch

We need a class that owns a char*. Let's build each member by reasoning about what must happen.

#include <cstring>   // strlen, strcpy
 
class MyString {
    char* data;      // owned resource
    std::size_t len;
 
public:
    // --- normal constructor ---
    MyString(const char* s = "") {
        len  = std::strlen(s);
        data = new char[len + 1];   // +1 for the '\0'
        std::strcpy(data, s);
    }

Why len+1? strings need a null terminator slot.

    // --- (1) Destructor: how the resource dies ---
    ~MyString() {
        delete[] data;              // [] because we did new[]
    }

Why delete[]? Array-new must be paired with array-delete, else UB.

    // --- (2) Copy constructor: born as a copy ---
    MyString(const MyString& other) {
        len  = other.len;
        data = new char[len + 1];   // OWN memory — deep copy
        std::strcpy(data, other.data);
    }

Why allocate fresh? So the new object owns an independent buffer; destroying one won't affect the other.

    // --- (3) Copy assignment: overwrite an existing object ---
    MyString& operator=(const MyString& other) {
        if (this == &other) return *this;   // guard self-assignment
        delete[] data;                      // free OLD resource
        len  = other.len;
        data = new char[len + 1];           // allocate new
        std::strcpy(data, other.data);
        return *this;                        // for chaining a=b=c
    }
};

WHY each line of `operator=` exists (steel-manned)

Intuition

The copy-and-swap idiom (the elegant alternative) Take other by value (this reuses the copy constructor), then swap guts:

MyString& operator=(MyString other) {  // by value → copies
    std::swap(data, other.data);
    std::swap(len,  other.len);
    return *this;                      // 'other' (old guts) dies here
}

Self-assignment-safe and exception-safe for free, because all allocation happens before any of *this is touched. The old buffer is freed automatically when other destructs.

Worked examples

Worked example Example 1 — copy constructor fires

MyString a("cat");
MyString b = a;     // copy ctor

Why ctor not assignment? b is being created. After this, a.data != b.data (two buffers), each holding "cat". Destroying both is safe.

Worked example Example 2 — assignment fires, old buffer freed

MyString a("cat");
MyString b("elephant");
b = a;              // copy assignment

Step 1 — why self-check? &a != &b, so we proceed. Step 2 — why delete[] data? b held "elephant"'s buffer; we must release it or leak. Step 3 — why new+strcpy? b gets its own "cat". Now both safe to destroy.

Worked example Example 3 — what the

default (broken) version does

// No user copy ops written → compiler shallow-copies
MyString a("hi");
{ MyString b = a; }   // b dies here → delete[] data
// a.data now dangling; a's destructor → delete[] again → CRASH

Why crash? Both objects shared one pointer; delete[] ran twice on it.

Modern footnote: Rule of Five & Rule of Zero

Active recall

What three members does the Rule of Three concern?

Destructor, copy constructor, and copy assignment operator.

Why does the Rule of Three exist?

If a class manages a resource manually, all three are needed together to avoid double-free, leaks, and aliasing bugs.

Distinguish copy constructor vs copy assignment by trigger.

Copy ctor: a new object is created from another. Copy assignment: an already-existing object is overwritten.

What is a shallow copy vs deep copy?

Shallow copies the pointer (shared buffer); deep allocates new memory and copies the contents.

Two bugs from default shallow copy of a pointer?

Double free on destruction, and aliasing (writing one corrupts the other).

Why must copy assignment guard against self-assignment?

Without it, freeing data before copying destroys the source you copy from (e.g. a = a).

Why must operator= free the old resource but the copy ctor must not?

The assigned-to object already owns a buffer (leak if not freed); the constructed object has none yet.

What signature is conventional for copy assignment?

T& operator=(const T& other) — returns reference for chaining.

What does copy-and-swap buy you?

Self-assignment safety and exception safety for free, by copying via value parameter then swapping.

Why pair new[] with delete[]?

Mismatched new/delete forms is undefined behavior.

What is the Rule of Zero?

Use RAII member types (string, vector, unique_ptr) so you write none of the special members.

Recall Feynman: explain to a 12-year-old

Imagine each object has a toy box (memory) and a note with the box's address. The lazy copy just photocopies the note, so now two kids point at the same box. When playtime ends, both kids try to throw the box away — but you can't throw away the same box twice, so everything breaks! The Rule of Three says: if you gave a kid a box, you must teach them three things — how to clean up the box, how to make their own copy of the box when born, and how to swap their box for a copy later. Do all three or none.

Connections

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, jab tumhare class ke andar koi raw pointer hota hai jo new se memory leta hai, tab problem shuru hoti hai. Agar tum copy constructor aur copy assignment khud nahi likhte, to compiler ek shallow copy banata hai — matlab sirf pointer ka address copy hota hai, andar ki memory nahi. Ab do objects ek hi heap buffer ko point karte hain. Jab dono destruct hote hain, dono delete[] chalate hain same pointer par → double free, program crash. Isi liye deep copy chahiye: nayi memory allocate karo aur content copy karo.

Rule of Three kehta hai: agar tumne in teeno me se ek bhi khud likha — destructor, copy constructor, ya copy assignment — to teeno likhne padenge. Kyunki teeno ek hi cheez describe karte hain: resource kaise paida, kaise copy, aur kaise destroy hota hai. Ek bhi chhoot gaya to bug pakka.

Sabse zyada galti operator= me hoti hai. Yaad rakho do baatein: (1) self-assignment guard — if (this == &other) return *this;, warna a = a me pehle apni memory free kar doge aur phir usi se copy karoge (garbage). (2) purani memory free karo — assignment me object pehle se ek buffer rakhta hai, use delete[] karo warna memory leak. Copy constructor me ye free wala step nahi hota kyunki object abhi-abhi bana hai, uske paas purana buffer hota hi nahi.

Smart tarika: copy-and-swap idiom — parameter ko value se lo (copy automatically ban jayegi), phir std::swap se andar ka data badal do. Ye self-assignment aur exception dono ke liye safe hai. Aur modern C++ me best — Rule of Zero: std::string, std::vector, unique_ptr use karo, to tumhe in teeno me se kuch likhna hi nahi padega.

Copy constructor and copy assignment — Rule of Three

WHAT are these three things?

WHY does the compiler-generated version break? (Shallow vs Deep)

HOW to write them — deriving a safe `MyString` from scratch

WHY each line of `operator=` exists (steel-manned)

Worked examples

Modern footnote: Rule of Five & Rule of Zero

Active recall

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — C++ Programming

Connections