Smart Pointers

// Raw pointer — who deletes it? When?
void bad() {
    int* p = new int(42);
    if (some_condition) return;   // LEAK — delete never called
    delete p;
}

// Smart pointer — always cleaned up
void good() {
    auto p = std::make_unique<int>(42);
    if (some_condition) return;   // OK — destructor runs, no leak
}

#include <memory>

// Preferred: make_unique (C++14)
auto sensor = std::make_unique<Sensor>(42, 23.5f);

// Access like a raw pointer
sensor->activate();
float v = sensor->read();

// unique_ptr is non-copyable, movable
auto s2 = std::move(sensor);  // sensor is now null; s2 owns it
// sensor.get() == nullptr

// Release ownership (raw pointer — you own it now)
Sensor* raw = s2.release();
delete raw;  // now you must delete it

// Reset to a new object (old object destroyed)
s2.reset(new Sensor(99, 0.0f));
s2.reset();  // destroys and sets to null

// Return unique_ptr from factory functions
std::unique_ptr<IDevice> create_device(const std::string& type) {
    if (type == "uart")  return std::make_unique<UartDevice>();
    if (type == "spi")   return std::make_unique<SpiDevice>();
    return nullptr;
}

// Caller takes ownership
auto dev = create_device("uart");
if (dev) dev->open("/dev/ttyS0");
// dev destroyed when it goes out of scope

// unique_ptr manages array correctly (calls delete[])
auto buf = std::make_unique<uint8_t[]>(1024);
buf[0] = 0xFF;
// But prefer std::vector<uint8_t> for dynamic arrays!

// Custom deleter for C file handles
auto fp = std::unique_ptr<FILE, decltype(&fclose)>(
    fopen("/etc/hostname", "r"), &fclose);

if (fp) {
    char line[128];
    fgets(line, sizeof(line), fp.get());
    std::puts(line);
}  // fclose called automatically

// Useful for OS resources (file descriptors, sockets)
struct FdDeleter {
    void operator()(int* fd) const {
        if (*fd >= 0) close(*fd);
        delete fd;
    }
};

// make_shared allocates object + control block in one allocation (efficient)
auto a = std::make_shared<Sensor>(1, 0.0f);
auto b = a;   // copy: both a and b own the sensor

std::cout << a.use_count() << '\n';  // 2

{
    auto c = a;  // use_count = 3
}   // c destroyed: use_count = 2

a.reset();   // a released: use_count = 1
// b still holds the sensor; it's alive
// b goes out of scope: use_count = 0 → Sensor destroyed

struct EventBus {
    std::vector<std::shared_ptr<Sensor>> subscribers;

    void subscribe(std::shared_ptr<Sensor> s) {
        subscribers.push_back(s);
    }
    void broadcast() {
        for (auto& s : subscribers)
            s->activate();
    }
};

auto s1 = std::make_shared<Sensor>(1, 0.0f);
EventBus bus;
bus.subscribe(s1);    // bus and caller both own s1

// s1 is still alive as long as bus holds a copy

// make_shared: single allocation (object + control block)
auto good = std::make_shared<Sensor>(1, 0.0f);  // ✓

// Direct constructor: two allocations
auto bad = std::shared_ptr<Sensor>(new Sensor(1, 0.0f));  // ✗

// Thread safety: ref-count operations are atomic, but the object itself is NOT
// Use mutex to protect shared object data when accessed from multiple threads

struct Node {
    int value;
    std::shared_ptr<Node> next;
    std::weak_ptr<Node>   parent;  // ← weak to break cycle
    Node(int v) : value(v) {}
};

auto root  = std::make_shared<Node>(1);
auto child = std::make_shared<Node>(2);

root->next   = child;        // root owns child (strong)
child->parent = root;        // child observes root (weak — no cycle!)

// To use a weak_ptr, promote to shared_ptr (may return nullptr)
if (auto p = child->parent.lock()) {
    std::cout << "parent value: " << p->value << '\n';  // 1
} else {
    std::cout << "parent is gone\n";
}

struct BadNode {
    std::shared_ptr<BadNode> next;   // shared both ways = cycle = leak!
};
auto a = std::make_shared<BadNode>();
auto b = std::make_shared<BadNode>();
a->next = b;
b->next = a;  // a and b keep each other alive forever

// Function signatures that express ownership clearly:

// Takes ownership (caller must pass owned pointer)
void take_device(std::unique_ptr<IDevice> dev);

// Borrows (caller keeps ownership, function doesn't store it)
void use_device(IDevice& dev);
void use_device(IDevice* dev);  // nullable borrow

// Shares ownership (function may outlive the call)
void register_device(std::shared_ptr<IDevice> dev);

// Observes without owning
void observe(std::weak_ptr<IDevice> dev);

// When an object needs to create a shared_ptr to itself:
class Server : public std::enable_shared_from_this<Server> {
public:
    void start_session() {
        auto self = shared_from_this();  // safe — returns shared_ptr<Server>
        // pass self to async callback; keeps Server alive
    }
};

// Only valid when Server is already managed by a shared_ptr:
auto srv = std::make_shared<Server>();
srv->start_session();  // OK