C++ Copy Constructor — Fixing Double-Free Shallow Copy Bugs

Every serious C++ program eventually needs to duplicate objects — passing one to a function, returning one from a method, or storing one in a container. At that moment, C++ must answer a critical question: what does 'make a copy' actually mean for this specific class? For a simple integer that answer is obvious, but the moment your class owns a raw pointer, opens a file handle, or manages a network socket, a naive byte-for-byte duplicate can silently corrupt your program. That's the problem the copy constructor was designed to solve.

The copy constructor is a special member function that C++ calls whenever an object is initialised from another object of the same type. It lets you define exactly what 'copy' means for your class — whether that's a shallow mirror image, a fully independent deep clone, or something in between. Without a thoughtful copy constructor, two seemingly separate objects can end up sharing the same underlying memory, leading to double-free crashes, dangling pointers, and data corruption that only shows up at the worst possible moment.

By the end of this article you'll understand why the compiler-generated copy constructor is sometimes a ticking time bomb, how to write a correct deep-copying version, when to delete it entirely, and how to talk confidently about it in a technical interview. We'll build a realistic DocumentBuffer class step by step so every concept has immediate, tangible context.

What the Compiler Generates — and Why That's Sometimes Dangerous

If you don't write a copy constructor, the compiler generates one for you. This default version performs a member-wise copy: it copies each data member from the source object into the new object one by one. For value types like int, double, or std::string, that works perfectly because those types already know how to copy themselves correctly.

The danger arrives with raw pointers. If your class holds a char or int pointing to heap memory, a member-wise copy duplicates the pointer value — the memory address — not the data it points to. Both the original object and the new copy now point at the exact same block of heap memory. Neither object knows the other exists.

When the first one is destroyed, its destructor frees that memory. When the second one is later destroyed, its destructor tries to free memory that's already gone. That's undefined behaviour, and on most platforms it's an immediate crash.

This is called a shallow copy, and understanding it deeply is the single most important prerequisite for writing correct C++ classes that manage resources.

#include <iostream>
#include <cstring>

namespace io::thecodeforge::examples {

// A naive buffer class that does NOT define a copy constructor.
// The compiler will generate a shallow copy — watch what happens.
class NaiveBuffer {
public:
    char* data;   
    int   size;

    NaiveBuffer(const char* text) {
        size = static_cast<int>(std::strlen(text)) + 1;
        data = new char[size];           
        std::strcpy(data, text);         
        std::cout << "[Construct] Allocated buffer at address "
                  << static_cast<void*>(data) << "\n";
    }

    ~NaiveBuffer() {
        std::cout << "[Destroy]   Freeing buffer at address "
                  << static_cast<void*>(data) << "\n";
        delete[] data;                   
    }
};

}

int main() {
    using namespace io::thecodeforge::examples;
    NaiveBuffer original("Hello, CodeForge");

    // The compiler's shallow copy constructor runs here.
    NaiveBuffer copyOfBuffer = original;  

    std::cout << "Original address:  " << static_cast<void*>(original.data) << "\n";
    std::cout << "Copy address:      " << static_cast<void*>(copyOfBuffer.data) << "\n";

    // When main() exits, the double-free crash occurs here.
    return 0;
}

Writing a Deep Copy Constructor That Actually Works

A deep copy constructor solves the shared-pointer problem by allocating brand-new memory for the copy and then copying the data across — not just the address. The result is two completely independent objects that happen to hold identical data at that moment in time.

The signature of a copy constructor is always the same pattern: ClassName(const ClassName& source). The parameter is a const reference to the same type. It must be a reference — if it were passed by value, C++ would need to copy it, which would call the copy constructor again, causing infinite recursion. The const is there because copying shouldn't modify the source.

Let's fix our NaiveBuffer by renaming it DocumentBuffer and adding a proper copy constructor, copy assignment operator, and destructor — the full Rule of Three in action.

#include <iostream>
#include <cstring>
#include <algorithm>

namespace io::thecodeforge::core {

class DocumentBuffer {
public:
    char* content;   
    int   capacity;  

    explicit DocumentBuffer(const char* text) {
        capacity = static_cast<int>(std::strlen(text)) + 1;
        content  = new char[capacity];
        std::strcpy(content, text);
        std::cout << "[Constructor] Created at " << (void*)content << "\n";
    }

    // --- The Deep Copy Constructor ---
    DocumentBuffer(const DocumentBuffer& source) {
        capacity = source.capacity;
        content  = new char[capacity];          // Allocate FRESH memory
        std::strcpy(content, source.content);   // Copy actual DATA
        std::cout << "[Copy Constructor] Cloned to " << (void*)content << "\n";
    }

    // --- The Deep Copy Assignment Operator ---
    DocumentBuffer& operator=(const DocumentBuffer& source) {
        if (this == &source) return *this;      // Self-assignment guard

        delete[] content;                       // Cleanup existing resource
        capacity = source.capacity;
        content  = new char[capacity];
        std::strcpy(content, source.content);
        std::cout << "[Copy Assignment] Re-assigned at " << (void*)content << "\n";
        return *this;
    }

    ~DocumentBuffer() {
        std::cout << "[Destructor] Freeing " << (void*)content << "\n";
        delete[] content;  
    }
};

}

int main() {
    using namespace io::thecodeforge::core;
    DocumentBuffer draft("TheCodeForge");
    DocumentBuffer backup = draft; // Copy Constructor
    return 0;
}

When to Delete the Copy Constructor — and the Move Constructor Alternative

Sometimes copying an object makes no logical sense. A database connection, a file handle, or a mutex represent unique real-world resources that can't meaningfully be duplicated. If you copy a database connection object, should both copies now own the same connection? The safest answer is to make copying impossible by deleting the copy constructor.

C++11 introduced the move constructor as a complementary tool. Where a copy says 'make me an identical twin', a move says 'transfer ownership to me — the original gives up its resource'. Moves are typically $O(1)$ operations because they just swap pointers, whereas deep copies are $O(N)$.

#include <iostream>
#include <string>
#include <utility>

namespace io::thecodeforge::db {

class DatabaseConnection {
private:
    std::string* conn_string;

public:
    explicit DatabaseConnection(const std::string& str) {
        conn_string = new std::string(str);
        std::cout << "[DB] Connection opened.\n";
    }

    // DISABLE COPYING
    DatabaseConnection(const DatabaseConnection&) = delete;
    DatabaseConnection& operator=(const DatabaseConnection&) = delete;

    // ENABLE MOVING (Ownership Transfer)
    DatabaseConnection(DatabaseConnection&& other) noexcept : conn_string(other.conn_string) {
        other.conn_string = nullptr; // Leave donor in valid but empty state
        std::cout << "[DB] Connection moved.\n";
    }

    ~DatabaseConnection() {
        if (conn_string) {
            delete conn_string;
            std::cout << "[DB] Connection closed.\n";
        }
    }
};

}

int main() {
    using namespace io::thecodeforge::db;
    DatabaseConnection conn("sql://prod:5432");
    // DatabaseConnection copy = conn; // This would cause COMPILE ERROR
    DatabaseConnection moved_conn = std::move(conn); // This works!
    return 0;
}

When the Copy Constructor Gets Called — and the Traps You'll Hit

The copy constructor isn't just for explicit =. It's triggered in three common scenarios that often surprise junior engineers:

1. Pass by value: void func(MyClass obj) — every call copies the object.
2. Return by value: MyClass create() { MyClass tmp; return tmp; } — the return value is copied unless copy elision kicks in.
3. Container insertion: std::vector<MyClass> vec; vec.push_back(obj); — stores a copy.

But here's where the traps lie: if you pass a temporary (rvalue) to a function that expects a parameter by value, the compiler may use the move constructor instead if available. If your class has only a copy constructor and not a move constructor, the copy constructor will be called even for temporaries — which is a performance hit. Also, brace initialisation (MyClass obj = {arg}) might call the copy constructor if the constructor is explicit.

Understanding when copying happens is critical for performance-critical code. Every unnecessary copy in a hot path adds O(n) time and memory pressure.

#include <iostream>
#include <vector>

namespace io::thecodeforge::examples {

class Tracker {
public:
    int id;
    Tracker(int i) : id(i) { std::cout << "Construct " << id << "\n"; }
    Tracker(const Tracker& s) : id(s.id) { std::cout << "Copy " << id << "\n"; }
    Tracker(Tracker&& s) noexcept : id(s.id) { s.id = -1; std::cout << "Move " << id << "\n"; }
    ~Tracker() { std::cout << "Destroy " << id << "\n"; }
};

Tracker create() {
    Tracker local(1);
    return local; // Moves or elides
}

void consume(Tracker t) { /* pass by value */ }
}

int main() {
    using namespace io::thecodeforge::examples;
    Tracker a(2);
    Tracker b = a;       // Copy
    Tracker c = create(); // Move or elision
    consume( create() );  // Move into parameter
    std::vector<Tracker> v;
    v.push_back(a);       // Copy into vector
    return 0;
}

Copy Elision and Return Value Optimization (RVO) — When the Copy Doesn't Happen

The C++ standard allows compilers to elide (skip) a copy or move constructor call under specific circumstances, even if the constructor has side effects. This is called copy elision. The most common form is Return Value Optimization (RVO): when a function returns a local variable, the compiler can construct it directly into the caller's variable, skipping the copy or move.

Since C++17, guaranteed copy elision is mandatory for certain cases: when a prvalue (pure rvalue) is used to initialise an object directly. That means MyClass obj = MyClass(42); constructs obj in place without calling the copy or move constructor — period.

Understanding elision is vital because you cannot rely on side effects in copy/move constructors for correctness. The compiler may or may not call them. RVO also affects performance: if you disable it (e.g., by returning std::move(local) instead of local), you may inhibit elision and force a move that's actually slower.

#include <iostream>

namespace io::thecodeforge::examples {

class Tracked {
public:
    Tracked() { std::cout << "default\n"; }
    Tracked(const Tracked&) { std::cout << "copy\n"; }
    Tracked(Tracked&&) noexcept { std::cout << "move\n"; }
    ~Tracked() { std::cout << "~destruct\n"; }
};

Tracked make() {
    Tracked local;
    return local; // RVO: may elide copy/move
}

}

int main() {
    using namespace io::thecodeforge::examples;
    Tracked obj = make(); // C++17: guaranteed elision
    Tracked x = Tracked(); // prvalue init: no copy
    return 0;
}

The Rule of Five: Expanding for Move Semantics

With C++11, the Rule of Three became the Rule of Five. If your class manages a resource, you should now consider defining:

• Destructor
• Copy constructor
• Copy assignment operator
• Move constructor
• Move assignment operator

If you define a destructor, copy constructor, or copy assignment operator, the compiler will deprecate the default move operations (they are implicitly defined, but you should explicitly define them for correctness and performance). Similarly, if you define move operations, the copy operations are implicitly deleted.

In practice, if you're following the Rule of Five, use the copy-and-swap idiom for the copy assignment operator. It provides strong exception safety and reduces code duplication. The move constructor and assignment operator can simply swap pointers.

#include <iostream>
#include <cstring>
#include <algorithm>

namespace io::thecodeforge::core {

class Resource {
    char* data_;
    size_t size_;
public:
    explicit Resource(const char* s) {
        size_ = std::strlen(s) + 1;
        data_ = new char[size_];
        std::strcpy(data_, s);
    }
    ~Resource() { delete[] data_; }

    // Copy
    Resource(const Resource& other) 
        : size_(other.size_), data_(new char[other.size_]) {
        std::strcpy(data_, other.data_);
    }
    Resource& operator=(Resource other) { // copy-and-swap
        swap(*this, other);
        return *this;
    }

    // Move
    Resource(Resource&& other) noexcept 
        : Resource() { // default constructor
        swap(*this, other);
    }
    Resource& operator=(Resource&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            data_ = other.data_;
            size_ = other.size_;
            other.data_ = nullptr;
            other.size_ = 0;
        }
        return *this;
    }

    friend void swap(Resource& a, Resource& b) noexcept {
        using std::swap;
        swap(a.data_, b.data_);
        swap(a.size_, b.size_);
    }
};

}

int main() {
    using namespace io::thecodeforge::core;
    Resource r1("Hello");
    Resource r2 = r1;           // copy
    Resource r3 = std::move(r1); // move
    r2 = Resource("World");     // move assignment
    return 0;
}