Prev Problem
Next Problem
Task
Discussion
Submissions
Solution
Report

118. SensorFrame Deep Copy Fix

A data-processing pipeline has reported that sensor readings become corrupted after frame duplication. The issue appears only when SensorFrame objects are copied. A minimal reproduction has been provided.

Your task is to investigate why the corruption occurs, identify the underlying ownership flaw, and update the class implementation so copied frames operate independently.

After your fix:

  • Modifying one frame must not affect another
  • Frames must maintain isolated storage
  • Behavior must be deterministic and free of corruption

Program Flow:

  1. Read 8 bytes
  2. Construct frame A
  3. Create frame B as a copy of A
  4. Modify B at index 3
  5. Print A
  6. Print B

Before fixing the class:

A and B both reflect the modification.

After fixing the class:

Only B reflects the modification; A must remain unchanged.

 

Example Input:

1 2 3 4 5 6 7 8

Example Output (After Fix):

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

 

Constraints:

  • The class must be corrected to ensure safe and independent behavior when copied
  • Memory management must be robust
  • Output formatting 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.