Prev Problem
Next Problem
Task
Discussion
Submissions
Solution
Report

117. Non-Copyable UART Handle

You are implementing a class that represents a UART hardware handle.

Each instance controls one physical UART peripheral, so it must not be copied.

Copying this object would incorrectly imply:

  • Two objects controlling the same UART
  • Conflicting writes
  • Multiple initializations
  • Incorrect baud configuration
  • Hardware misuse in firmware

To prevent this, copying must be explicitly disabled.

You must implement:

  • A constructor initializing the UART with a baud rate
  • A sendByte() function that prints the transmitted byte
  • A deleted copy constructor
  • A deleted copy assignment operator

Your class must be non-copyable.

Demonstration requirement:

Inside main(), an attempted copy is included:

// UARTHardware copy = uart;   // This line should NOT compile after your implementation

This line is intentionally commented out.

If the user un-comments it, the code must fail to compile, proving copying is forbidden.

Program Flow:

  1. Read a baud rate
  2. Read a byte to send
  3. Create a UART object
  4. Attempted copy line is present (commented)
  5. Send the byte

 

Example Input:

9600 65

Example Output:

TX: 65

 

Constraints:

  • Baud rate is a positive integer
  • Byte value is 0–255
  • Copying must be disallowed via deletion
  • Output 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.