75. unique_ptr RAII Basics

1. std::unique_ptr (The Embedded Standard)

Represents exclusive ownership. Only one pointer can own the resource.

• Copying: Banned (Compiler error).
• Moving: Allowed (Transfers ownership).
• Overhead: Zero. It is exactly the same size as a raw pointer.

#include <memory>

void setup_sensor() {
    // Create unique pointer (Preferred syntax: make_unique)
    std::unique_ptr<Sensor> s = std::make_unique<Sensor>(10);
    
    s->init(); // Use -> just like a raw pointer
    
    // No delete needed! 
    // When function returns, 's' is destroyed -> calls ~Sensor() -> frees memory.
}

2. std::shared_ptr (Reference Counted)

Represents shared ownership. Multiple pointers can point to the same object.

• It maintains a Reference Count. Every time you copy the pointer, count +1. When a pointer dies, count -1.
• The memory is freed only when the count hits 0.

std::shared_ptr<Data> p1 = std::make_shared<Data>();
{
    std::shared_ptr<Data> p2 = p1; // Count = 2
} // p2 dies. Count = 1. Data still exists.
// p1 dies. Count = 0. Data deleted.

3. std::weak_ptr

A non-owning observer of a shared_ptr. It doesn't increase the reference count. Used to break Circular Dependencies (A points to B, B points to A) which cause memory leaks.

1. unique_ptr for Drivers

Hardware drivers usually have single ownership. A UART object manages a specific hardware block.

Using unique_ptr<UART> ensures that if the driver is replaced or shut down, the cleanup (destructor) happens automatically.

2. Custom Deleters (No Heap Required)

Smart pointers are often associated with new/delete (Heap), but they can manage any resource. You can teach a unique_ptr to call a specific function (like fclose or free_buffer) instead of delete.

// A pointer that calls 'close_file' instead of 'delete'
auto deleter = [](FILE* f) { fclose(f); };
std::unique_ptr<FILE, decltype(deleter)> file_ptr(fopen("log.txt", "w"), deleter);

// When file_ptr goes out of scope, fclose() is called automatically.

3. Factory Patterns

Factories that return std::unique_ptr<Base> allow you to return different derived driver types safely without worrying about who is responsible for deleting them.