120. Copy Semantics-II
Question.4
Two functions are designed to receive a 128-byte SensorData object for processing:
Option A -- by value:
void process(SensorData data);Option B -- by const reference:
void process(const SensorData& data);In a loop calling the function 1000 times, how much extra stack churn does Option A cause compared to Option B?
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
bholds a pointer to a buffer,agets 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
| 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). |
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)
| 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. |