Prev Problem
Next Problem
Task
Discussion
Submissions
Solution
Report

115. Deep Copy Constructor

You are implementing a sensor packet class that owns dynamically allocated memory.
The class manages a fixed-size buffer of exactly 8 bytes stored on the heap.

Your goal is to correctly implement resource ownership using:

  • A constructor
  • A deep copy constructor
  • A destructor

This problem is designed to verify correct handling of dynamic memory in Embedded C++, where improper copy behavior can cause double-free, memory corruption, or silent data errors.

Class Design:

Private:

  • uint8_t* data;
    Dynamically allocated array of size 8

Public operations:

  • Constructor taking an input array uint8_t arr[8]
  • Copy constructor: SensorData(const SensorData& other)
  • Destructor: ~SensorData()
  • void setIndex3()
    Sets data[3] = 99
  • void print() const
    Prints all 8 bytes separated by spaces

Program Flow:

  1. Read 8 integer values from input
  2. Construct object a using those values
  3. Copy object a into object b using copy initialization
  4. Modify b by calling setIndex3()
  5. Print a, then print b

Correct Behavior:

  • Object a must retain the original data
  • Object b must show the modified value at index 3
  • Each object must own its own independent buffer
  • Program must run with no memory errors

 

Example Input:

1 2 3 4 5 6 7 8

Example Output:

1 2 3 4 5 6 7 8 
1 2 3 99 5 6 7 8

 

Constraints:

  • Exactly 8 input values
  • Each input value is guaranteed to be in the range 0–255
  • Memory must be allocated using new uint8_t[8]
  • Copy constructor must:
    • Allocate a new buffer
    • Copy all 8 bytes from the source object
  • Destructor must release memory using delete[]
  • Objects must not share the same data pointer
  • Output format must match exactly

 

 

 

Need Help? Refer to the Quick Guide below

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

FeatureShallow Copy (Default)Deep Copy (Custom)
PointersCopies the address (pointer value).Copies the data at the address.
MemoryShared between objects (Risky).Independent memory per object.
DestructionDouble-Free crash (Both free same ptr).Safe (Each frees its own).
SpeedFast (copying 4 bytes).Slow (copying N bytes).

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)

PitfallDetails
❌ Double FreeThe #1 bug with default copy. Object A is destroyed (frees ptr). Object B is destroyed (frees same ptr) → System Hard Fault.
❌ Self-AssignmentIf you write obj = obj;, a naive assignment operator might delete ptr before copying from it, corrupting data. Always check if (this == &other).
❌ Object SlicingIf you assign a Derived object to a Base object variable (Base b = Derived d;), the "Derived" parts are sliced off (lost). Always pass polymorphic objects by pointer or reference.
✅ Pass by ReferenceTo avoid the performance cost of Deep Copies, always pass objects to functions using const Reference (void func(const Buffer& b)), not by value.