Copy Semantics (The Rule of Three)

In C++, when you assign one object to another (a = b) or pass by value, the compiler performs a Shallow Copy by default. It copies the bits of the object exactly.

• Safe for simple types (int, float, GPIO_Config).
• Dangerous for objects managing pointers or resources. If b holds a pointer to a buffer, a gets a copy of the pointer, not the buffer. Both objects now point to the same memory. When one dies, it frees the memory, leaving the other with a Dangling Pointer.

To fix this, we implement Deep Copy logic using the Copy Constructor and Copy Assignment Operator.

Syntax & Usage

1. Copy Constructor

Used when creating a new object from an existing one (Buffer b2 = b1;).

class Buffer {
    int* ptr;
    int size;
public:
    // 1. Normal Constructor
    Buffer(int s) : size(s) { ptr = new int[size]; }

    // 2. Copy Constructor (Deep Copy)
    Buffer(const Buffer& other) : size(other.size) {
        ptr = new int[size]; // Allocate NEW memory
        memcpy(ptr, other.ptr, size * sizeof(int)); // Copy data
    }
    
    ~Buffer() { delete[] ptr; }
};

2. Copy Assignment Operator

Used when updating an already existing object (b2 = b1;). This is more complex because b2 already has memory that must be cleaned up first.

    // 3. Copy Assignment Operator
    Buffer& operator=(const Buffer& other) {
        if (this == &other) return *this; // Handle self-assignment (b1 = b1)

        delete[] ptr;        // Free old memory
        
        size = other.size;   // Copy size
        ptr = new int[size]; // Allocate NEW memory
        memcpy(ptr, other.ptr, size * sizeof(int)); // Copy data
        
        return *this;        // Return reference for chaining (a = b = c)
    }

Deep vs. Shallow Copy Visualization

Relevance in Embedded/Firmware

1. The "Rule of Three"

If your class needs a custom Destructor (to free memory or close a handle), you must also define a Copy Constructor and Copy Assignment Operator.

In firmware, this often applies to circular buffers, packet managers, or flash file system wrappers.

2. Disabling Copy (Hardware Ownership)

For hardware drivers (e.g., UART, SPI), copying makes no sense. You cannot "clone" a physical peripheral.

The standard practice is to delete copy semantics to enforce Unique Ownership.

class UART {
public:
    UART(const UART&) = delete;            // ❌ No Copying
    UART& operator=(const UART&) = delete; // ❌ No Assignment
};

Common Pitfalls (Practical Tips)