Shallow Copy And Deepcopy In C++

Understanding how objects are copied in C++ is fundamental to writing solid, bug-free software. Consider this: when a class manages resources like dynamic memory, file handles, or network sockets, the default behavior provided by the compiler is often insufficient—and dangerous. The distinction between a shallow copy and a deep copy sits at the heart of resource management in C++, dictating whether your program runs smoothly or crashes with double-free errors and memory leaks.

What Happens During Object Copying?

In C++, copying occurs in several common scenarios: passing an object by value to a function, returning an object by value from a function, or explicitly initializing a new object with an existing one (e.By default, the compiler generates a copy constructor and a copy assignment operator for your class. Practically speaking, , MyClass obj2 = obj1;). g.These compiler-generated versions perform a member-wise copy, meaning they copy every data member from the source object to the destination object individually Not complicated — just consistent..

For simple data types like int, double, or std::string (which manages its own memory internally), this default behavior is perfectly safe and efficient. The trouble begins when your class contains raw pointers or references to external resources. Now, a member-wise copy of a pointer copies the address the pointer holds, not the data it points to. This results in two distinct objects pointing to the exact same memory address—the definition of a shallow copy.

Some disagree here. Fair enough Most people skip this — try not to..

Shallow Copy: The Default Behavior

A shallow copy creates a new object that shares the underlying resource with the original object. Both the source and the destination objects hold pointers referencing the same memory block.

Consider a simple class managing a dynamic array:

class ShallowArray {
private:
    int* data;
    size_t size;

public:
    ShallowArray(size_t s) : size(s) {
        data = new int[size];
    }

    ~ShallowArray() {
        delete[] data; // Releases the memory
    }

    // Compiler generates copy constructor and assignment operator implicitly
    // ShallowArray(const ShallowArray& other) : data(other.data), size(other.size) {}
};

If you execute ShallowArray arr2 = arr1;, the compiler-generated copy constructor copies the pointer value arr1.data into arr2.In practice, data. Now, arr1 and arr2 both point to the same integer array on the heap.

The Dangers of Shallow Copying

This shared ownership creates two critical problems:

1. Double Free Error (Double Deletion): When arr1 goes out of scope, its destructor runs and executes delete[] data. The memory is freed. Moments later, arr2 goes out of scope. Its destructor runs and attempts to delete[] data again. Deleting memory that has already been freed is undefined behavior, typically leading to an immediate program crash (heap corruption).
2. Unintended Side Effects (Aliasing): Because both objects share the same memory, modifying the data through arr1 (e.g., arr1.data[0] = 10;) instantly changes the data visible to arr2. The objects are no longer independent; they are aliases for the same resource. This violates the principle of value semantics, where a copy should be an independent clone.

Shallow copying is only acceptable when the class does not own the resource (e.Plus, g. On the flip side, , a non-owning observer pointer) or when the resource is reference-counted (like std::shared_ptr). For unique ownership of raw resources, you must implement a deep copy Worth keeping that in mind..

Deep Copy: Independent Resource Ownership

A deep copy allocates new memory for the destination object and copies the actual data from the source resource into this new memory block. On the flip side, after a deep copy, the source and destination objects are completely independent. Modifying one does not affect the other, and destroying one does not invalidate the other Practical, not theoretical..

To achieve this, you must explicitly define the Copy Constructor and the Copy Assignment Operator (often called the "Rule of Three" along with the Destructor). In modern C++ (C++11 and later), you should also consider the Move Constructor and Move Assignment Operator (Rule of Five), but the copy operations remain the foundation for deep copying logic Most people skip this — try not to. Practical, not theoretical..

Implementing the Copy Constructor

The copy constructor initializes a new object from an existing one.

class DeepArray {
private:
    int* data;
    size_t size;

public:
    DeepArray(size_t s) : size(s) {
        data = new int; // Value-initialize to 0
    }

    // 1. Copy Constructor
    DeepArray(const DeepArray& other) : size(other.So size) {
        // Allocate NEW memory
        data = new int[size];
        // Copy the CONTENTS (deep copy)
        std::copy(other. Which means data, other. data + size, data);
        std::cout << "Deep Copy Constructor called.

    ~DeepArray() {
        delete[] data;
    }
    
    // ... Assignment operator needed below ...
};

Implementing the Copy Assignment Operator

The copy assignment operator handles the case where an already existing object is assigned a new value (obj1 = obj2;). Consider this: this is trickier than the constructor because the destination object (obj1) already owns a resource that must be cleaned up before taking ownership of the new copy. It must also handle self-assignment (obj1 = obj1;).

    // 2. Copy Assignment Operator
    DeepArray& operator=(const DeepArray& other) {
        // CRITICAL: Check for self-assignment
        if (this == &other) {
            return *this;
        }

        // 1. Clean up existing resource of the destination
        delete[] data;

        // 2. Copy simple members
        size = other.size;

        // 3. Allocate new resource and copy data
        data = new int[size];
        std::copy(other.data, other.

        std::cout << "Deep Copy Assignment called.\n";
        return *this;
    }

Key Steps in Assignment Operator:

1. Self-assignment check: if (this == &other). Without this, delete[] data would destroy the source data before we copy it, leading to a crash or garbage data.
2. Release old resource: delete[] data frees the memory obj1 previously owned.
3. Allocate new resource: new int[size] gets fresh memory.
4. Copy data: std::copy duplicates the values.
5. Return *this: Allows chaining (a = b = c).

The Copy-and-Swap Idiom: Exception Safety

The manual implementation above has a subtle flaw: Exception Safety. If new int[size] throws std::bad_alloc (memory exhaustion), the size member has already been updated, but data is now a dangling pointer (or null). The object is left in a corrupted state.

The Copy-and-Swap Idiom solves this elegantly by leveraging the copy constructor (which is exception-safe: if allocation fails, the new object isn't created, and the original remains untouched) and a swap function (which should never throw) But it adds up..

    // Helper swap function (noexcept)
    friend void swap(DeepArray& first, DeepArray& second) noexcept {
        using std::swap;
        swap(first.data, second.data);
        swap(first.size, second.size);
    }

    // Copy Assignment using Copy-and-Swap
    DeepArray& operator=(DeepArray other) { // Note: pass BY VALUE
        // 1. Also, swap resources with the temporary copy. 'other' is a deep copy created by copy constructor (safe).
        // 2. //    If allocation fails here, *this is unchanged.
        
        swap(*this, other); // noexcept
        
        // 3.