Copy Constructor in C++: Deep Dive with Real-World Examples

#include <iostream>
#include <cstring>

// 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;   // Raw pointer — the source of all our trouble
    int   size;

    // Constructor: allocates memory and copies the input text
    NaiveBuffer(const char* text) {
        size = static_cast<int>(std::strlen(text)) + 1;
        data = new char[size];           // Allocate on the heap
        std::strcpy(data, text);         // Copy text into our buffer
        std::cout << "[Construct] Allocated buffer at address "
                  << static_cast<void*>(data) << "\n";
    }

    // Destructor: frees the heap memory
    ~NaiveBuffer() {
        std::cout << "[Destroy]   Freeing buffer at address "
                  << static_cast<void*>(data) << "\n";
        delete[] data;                   // First destroy: fine. Second destroy: CRASH.
    }

    void print() const {
        std::cout << "Buffer contains: " << data << "\n";
    }
};

int main() {
    NaiveBuffer original("Hello, CodeForge");

    // The compiler's shallow copy constructor runs here.
    // copyOfBuffer.data points to THE SAME memory as original.data.
    NaiveBuffer copyOfBuffer = original;  // <-- Danger: shallow copy

    std::cout << "Original address:  " << static_cast<void*>(original.data) << "\n";
    std::cout << "Copy address:      " << static_cast<void*>(copyOfBuffer.data) << "\n";
    std::cout << "(Same address? Yes. That is the problem.)\n\n";

    // When main() exits, both destructors run.
    // copyOfBuffer is destroyed first: frees the shared memory. OK.
    // original is destroyed second: tries to free already-freed memory. CRASH.
    return 0;
}

#include <iostream>
#include <cstring>

class DocumentBuffer {
public:
    char* content;   // Heap-allocated text storage
    int   capacity;  // Number of bytes allocated

    // --- Regular constructor ---
    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 '" << content
                  << "' at " << static_cast<void*>(content) << "\n";
    }

    // --- Copy constructor (deep copy) ---
    // Called when: DocumentBuffer b = a;  OR  passing by value  OR  returning by value
    DocumentBuffer(const DocumentBuffer& source) {
        // Allocate FRESH memory — do not copy the pointer itself
        capacity = source.capacity;
        content  = new char[capacity];          // New allocation
        std::strcpy(content, source.content);   // Copy the DATA, not the address
        std::cout << "[Copy Constructor] Copied '" << content
                  << "' to new address " << static_cast<void*>(content) << "\n";
    }

    // --- Copy assignment operator (also deep copy) ---
    // Called when: existingObject = anotherExistingObject;
    DocumentBuffer& operator=(const DocumentBuffer& source) {
        if (this == &source) {          // Self-assignment guard: a = a; is legal
            return *this;
        }
        delete[] content;               // Free old memory before we overwrite the pointer
        capacity = source.capacity;
        content  = new char[capacity];
        std::strcpy(content, source.content);
        std::cout << "[Copy Assignment]  Assigned '" << content
                  << "' to address " << static_cast<void*>(content) << "\n";
        return *this;
    }

    // --- Destructor ---
    ~DocumentBuffer() {
        std::cout << "[Destructor]       Freeing '" << content
                  << "' at " << static_cast<void*>(content) << "\n";
        delete[] content;  // Each object owns its own memory, so this is safe
    }

    void append(const char* extra) {
        int newCapacity = capacity + static_cast<int>(std::strlen(extra));
        char* newContent = new char[newCapacity];
        std::strcpy(newContent, content);
        std::strcat(newContent, extra);
        delete[] content;      // Release old buffer
        content  = newContent;
        capacity = newCapacity;
    }

    void print(const char* label) const {
        std::cout << label << ": '" << content << "'\n";
    }
};

int main() {
    std::cout << "=== Scenario 1: Copy construction ===\n";
    DocumentBuffer draft("Initial draft");
    DocumentBuffer backup = draft;           // Copy constructor fires here

    // Modify the original — backup must NOT change
    draft.append(" [EDITED]");
    draft.print("draft ");
    backup.print("backup");  // Should still say "Initial draft"

    std::cout << "\n=== Scenario 2: Copy assignment ===\n";
    DocumentBuffer archive("Old archive");
    archive = draft;                         // Copy assignment operator fires here
    archive.print("archive");

    std::cout << "\n=== Cleanup ===\n";
    // All three destructors run safely — each owns separate memory
    return 0;
}

#include <iostream>
#include <string>
#include <stdexcept>

// Models a resource that must NOT be copied — only moved or destroyed.
class DatabaseConnection {
public:
    std::string connectionString;
    bool        isOpen;

    // Regular constructor: 'opens' the connection
    explicit DatabaseConnection(const std::string& connStr)
        : connectionString(connStr), isOpen(true) {
        std::cout << "[Open]  Connection to '" << connectionString << "' established.\n";
    }

    // DELETE the copy constructor — copying a connection makes no sense.
    // Any attempt to copy will be a compile-time error.
    DatabaseConnection(const DatabaseConnection&)            = delete;
    DatabaseConnection& operator=(const DatabaseConnection&) = delete;

    // MOVE constructor: transfer ownership without duplicating the resource
    DatabaseConnection(DatabaseConnection&& donor) noexcept
        : connectionString(std::move(donor.connectionString)),
          isOpen(donor.isOpen) {
        donor.isOpen = false;   // The donor no longer owns the connection
        donor.connectionString = "<moved-from>";
        std::cout << "[Move]  Ownership transferred. Donor is now empty.\n";
    }

    void query(const std::string& sql) const {
        if (!isOpen) {
            throw std::runtime_error("Cannot query: connection has been moved or closed.");
        }
        std::cout << "[Query] Executing: " << sql << "\n";
    }

    ~DatabaseConnection() {
        if (isOpen) {
            std::cout << "[Close] Connection to '" << connectionString << "' closed.\n";
        } else {
            std::cout << "[Close] Nothing to close (was moved).\n";
        }
    }
};

// A repository that OWNS the connection by moving it in
class UserRepository {
    DatabaseConnection connection;  // Takes ownership
public:
    explicit UserRepository(DatabaseConnection&& conn)
        : connection(std::move(conn)) {}   // Move constructor fires here

    void fetchUser(int userId) const {
        connection.query("SELECT * FROM users WHERE id = " + std::to_string(userId));
    }
};

int main() {
    DatabaseConnection conn("postgres://localhost:5432/mydb");

    // This would be a COMPILE ERROR — uncomment to verify:
    // DatabaseConnection connCopy = conn;  // error: use of deleted function

    // Move the connection into the repository (transfer ownership)
    UserRepository repo(std::move(conn));

    // conn is now in a 'moved-from' state — don't use it
    repo.fetchUser(42);

    return 0;  // repo's destructor closes the connection cleanly
}