Deep Copy Assignment Buffer

Question

Problem: Deep Copy Assignment Buffer. Solve this hands-on electronics task on EWskills.

Accepted Answer

#include 
#include 
using namespace std;

class SensorBuffer {
private:
    uint8_t* data;
    int size;

public:
    // Constructor: allocate buffer
    SensorBuffer(int n) : size(n) {
        data = new uint8_t[size];
    }

    // Destructor: free buffer
    ~SensorBuffer() {
        delete[] data;
    }

    // Copy assignment operator: deep copy
    SensorBuffer& operator=(const SensorBuffer& other) {
        if (this == &other) {
            return *this; // Handle self-assignment
        }

        delete[] data;              // Release old memory
        size = other.size;          // Copy size
        data = new uint8_t[size];   // Allocate new buffer

        for (int i = 0; i < size; i++) {
            data[i] = other.data[i];
        }

        return *this;
    }

    void set(int index, uint8_t value) {
        data[index] = value;
    }

    void print() const {
        for (int i = 0; i < size; i++) {
            cout << (int)data[i];
            if (i != size - 1) cout << " ";
        }
    }
};

int main() {
    int N1, N2;

    cin >> N1;
    SensorBuffer A(N1);
    for (int i = 0; i < N1; i++) {
        int temp;
        cin >> temp;
        A.set(i, (uint8_t)temp);
    }

    cin >> N2;
    SensorBuffer B(N2);
    for (int i = 0; i < N2; i++) {
        int temp;
        cin >> temp;
        B.set(i, (uint8_t)temp);
    }

    A = B;

    A.print();
    return 0;
}

Explanation & Logic Summary

This class manages heap-allocated memory, so the copy assignment operator must ensure exclusive ownership.

The correct deep-copy process is:

Check for self-assignment
Release previously allocated memory
Allocate a new buffer matching the source size
Copy every byte from the source buffer

A shallow copy (copying only the pointer) would result in:

Multiple objects referencing the same memory
Double-free errors during destruction
Data corruption and unstable behavior

Deep copying ensures safe and predictable behavior in memory-constrained and safety-critical embedded systems.

Firmware Relevance & Real-World Context

In real embedded and firmware systems, dynamically allocated buffers are often used for:

Sensor sample storage
ADC or DMA data snapshots
Communication packet assembly
Variable-length protocol parsing

Incorrect handling of buffer ownership is a frequent source of:

Memory corruption
Hard faults
System resets

This practice problem reinforces correct deep-copy semantics, a critical Embedded C++ skill for building robust and maintainable firmware.

Feature	Shallow Copy (Default)	Deep Copy (Custom)
Pointers	Copies the address (pointer value).	Copies the data at the address.
Memory	Shared between objects (Risky).	Independent memory per object.
Destruction	Double-Free crash (Both free same ptr).	Safe (Each frees its own).
Speed	Fast (copying 4 bytes).	Slow (copying N bytes).

Pitfall	Details
❌ Double Free	The #1 bug with default copy. Object A is destroyed (frees ptr). Object B is destroyed (frees same ptr) → System Hard Fault.
❌ Self-Assignment	If you write `obj = obj;`, a naive assignment operator might `delete ptr` before copying from it, corrupting data. Always check `if (this == &other)`.
❌ Object Slicing	If 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 Reference	To avoid the performance cost of Deep Copies, always pass objects to functions using `const Reference` (`void func(const Buffer& b)`), not by value.

116. Deep Copy Assignment Buffer

Syntax & Usage

Deep vs. Shallow Copy Visualization

Relevance in Embedded/Firmware

Common Pitfalls (Practical Tips)