Copy Control

Chapter 1: The Copy Constructor

A copy constructor initializes a new object as a copy of an existing object. Its first parameter is a reference to const of the class type:

c++
class Foo {
public:
    Foo();                     // default constructor
    Foo(const Foo&);            // copy constructor
};

When Is It Called?

Copy initialization happens in more places than you might expect:

The Synthesized Copy Constructor

If you don't define one, the compiler generates a synthesized copy constructor that copies each non-static member using that member's own copy constructor (for class types) or direct copy (for built-in types). This is memberwise copy.

Chapter 2: The Copy-Assignment Operator

The copy-assignment operator is called when you assign one existing object to another:

c++
class HasPtr {
public:
    HasPtr& operator=(const HasPtr &rhs) {
        auto newps = new string(*rhs.ps);  // 1. copy the resource
        delete ps;                        // 2. free old resource
        ps = newps;                       // 3. point to new copy
        i = rhs.i;
        return *this;                     // 4. return *this
    }
};

Copy-and-Swap Idiom

An elegant pattern that handles self-assignment and provides strong exception safety:

c++
class HasPtr {
    friend void swap(HasPtr&, HasPtr&);
public:
    // Note: parameter is by VALUE (makes a copy)
    HasPtr& operator=(HasPtr rhs) {  // copy made here
        swap(*this, rhs);            // swap our guts with the copy
        return *this;                // rhs destroyed, frees old data
    }
};

Chapter 3: The Destructor

The destructor is called when an object is destroyed. It releases resources acquired during the object's lifetime:

c++
class HasPtr {
public:
    ~HasPtr() { delete ps; }  // free the dynamic string
};

When Is the Destructor Called?

The destructor body runs first, then members are destroyed in reverse order of declaration. For class-type members, their own destructors are called. For built-in types (pointers, ints), nothing happens — which is why raw pointers to dynamic memory need explicit delete.

Chapter 4: The Rule of Three/Five

If a class needs a custom destructor, it almost certainly needs a custom copy constructor and copy-assignment operator too. This is the Rule of Three.

C++11 extended this to the Rule of Five: if you define any copy-control member, also define (or explicitly default/delete) the move constructor and move-assignment operator.

= default and = delete

c++
class NoCopy {
public:
    NoCopy() = default;                // use synthesized default ctor
    NoCopy(const NoCopy&) = delete;    // no copying allowed
    NoCopy& operator=(const NoCopy&) = delete;  // no assignment
    ~NoCopy() = default;              // use synthesized destructor
};

Chapter 5: Value-like vs Pointer-like Classes

When designing copy control, you have two fundamental choices: should copies of your class behave like values or like pointers?

Value-like Copy Control

c++
// Deep copy: each HasPtr owns its own string
HasPtr(const HasPtr &p) : ps(new string(*p.ps)), i(p.i) {}
HasPtr& operator=(const HasPtr &rhs) {
    auto newp = new string(*rhs.ps);
    delete ps;
    ps = newp; i = rhs.i;
    return *this;
}

Chapter 6: Move Semantics

Copying is safe but expensive. When an object is about to be destroyed anyway (a temporary, or a variable being returned), why copy its resources? Just steal them. This is move semantics.

c++
class StrVec {
public:
    // Move constructor: steal resources from rhs
    StrVec(StrVec &&rhs) noexcept
        : elements(rhs.elements), first_free(rhs.first_free), cap(rhs.cap) {
        // Leave rhs in a valid but unspecified state
        rhs.elements = rhs.first_free = rhs.cap = nullptr;
    }

    // Move assignment: free our resources, steal from rhs
    StrVec& operator=(StrVec &&rhs) noexcept {
        if (this != &rhs) {
            free();                   // free our existing resources
            elements = rhs.elements;  // steal rhs's resources
            first_free = rhs.first_free;
            cap = rhs.cap;
            rhs.elements = rhs.first_free = rhs.cap = nullptr;
        }
        return *this;
    }
};

swap: The Secret Weapon

Defining a custom swap for your class enables the copy-and-swap idiom and is used by standard algorithms. For classes that manage resources, swapping pointers is far cheaper than copying:

c++
class HasPtr {
    friend void swap(HasPtr&, HasPtr&);
    // ...
};
inline void swap(HasPtr &lhs, HasPtr &rhs) {
    using std::swap;
    swap(lhs.ps, rhs.ps);  // swap pointers, not string data
    swap(lhs.i, rhs.i);    // swap ints
}

Chapter 7: Rvalue References

Move semantics need a way to detect objects that are safe to move from. Enter rvalue references, declared with &&:

c++
int i = 42;
int &r = i;           // lvalue reference: binds to lvalue (named object)
// int &&rr = i;       // ERROR: can't bind rvalue ref to lvalue
int &&rr = i * 42;    // OK: bind rvalue ref to temporary (rvalue)
int &&rr2 = std::move(i);  // OK: move "casts" lvalue to rvalue

Lvalues vs Rvalues

c++
// Without move: expensive copy
vector<string> v1 = getHugeVector();   // copies return value

// With move: cheap pointer swap
vector<string> v2 = std::move(v1);     // steals v1's guts
// v1 is now empty (valid but unspecified)

Chapter 8: Object Lifecycle Simulator

Let's trace every copy-control operation as objects are created, copied, moved, assigned, and destroyed. This is how you debug copy-control issues in real code.

Chapter 9: Beyond — Connections

Copy control is the mechanism that makes C++ classes behave like built-in types. Get it right, and your classes compose seamlessly. Get it wrong, and you get crashes, leaks, and corruption.

Continue Reading

Next up: Chapter 15: Object-Oriented Programming — inheritance, virtual functions, and dynamic binding.