Control Block (separate allocation from the object):
┌─────────────────────────────────────┐
│ strong_count  (std::atomic<size_t>) │  Number of shared_ptr owners
│ weak_count    (std::atomic<size_t>) │  Number of weak_ptr observers + 1 if strong > 0
│ deleter       (function pointer)    │  Called when strong_count reaches 0
│ allocator     (function pointer)    │  Called to deallocate the control block itself
└─────────────────────────────────────┘

std::shared_ptr<T> object layout:
┌──────────────────┐
│ T* ptr_          │  (pointer to the managed object)
│ ControlBlock* cb_│  (pointer to the control block)
└──────────────────┘
sizeof(std::shared_ptr<T>) == 16 (two pointers on x86_64)

int* raw = new int(42);
std::shared_ptr<int> p1(raw);
std::shared_ptr<int> p2(raw);  // BUG: second control block, double-free!
```
:::

### Reference Count State Machine

The control block implements a two-counter state machine. Let $s$ denote `strong_count` and $w$
Denote `weak_count`. The following state transitions are defined [N4950 S20.11.3.5]:

```
State (s, w) where s >= 0, w >= 0, w >= 1 when s > 0
               ┌──────────────────────────────────────────┐
               │                                          │
               v                                          │
  ┌─────────────────┐   s becomes 0    ┌──────────────────┐
  │ s > 0, w >= 1   │ ───────────────→ │ s = 0, w >= 1    │
  │ Object ALIVE    │  run deleter,    │ Object DESTROYED │
  │ Control block   │  destroy object  │ Control block    │
  │ allocated       │                  │ still allocated  │
  └─────────────────┘                  └────────┬─────────┘
         │        ^                            │
   s++   │        │ s-- (s > 0)        w--     │
   (copy)│        │ (destroy)         (weak    │
         │        │                    reset)  │
         │        │                            v
         │        │                    ┌──────────────────┐
         │        └──────────────────  │ s = 0, w = 0     │
         │            w++ (new         │ Control block    │
         │            weak_ptr)        │ FREED            │
         └────────────────────────────└──────────────────┘
```

**Invariant:** When $s \gt 0$, $w \ge 1$. The control block itself holds a "self-reference" weak
Count so it cannot deallocate while the object is alive. Formally:

- **Object lifetime:** The managed object exists if and only if $s \gt 0$.
- **Deleter invocation:** When $s$ transitions from 1 to 0, the deleter is invoked.
- **Control block deallocation:** When both $s = 0$ and $w = 0$The control block memory is freed
 via the stored allocator (or `operator delete` by default).

This two-phase destruction is critical: the object dies first (when strong owners vanish), but the
Control block survives until all weak observers have been cleaned up. This is what allows
`weak_ptr::expired()` and `weak_ptr::lock()` to function correctly even after the object is gone.

### Control Block Memory Alignment

On typical 64-bit implementations, the control block layout with padding looks like:

```
Offset  Size  Field
------  ----  -----
0x00    8     strong_count  (std::atomic<size_t>)
0x08    8     weak_count    (std::atomic<size_t>)
0x10    8     deleter       (type-erased function pointer / vtable)
0x18    8     allocator     (type-erased function pointer / vtable)
              ──────────────────────
              32 bytes minimum (without make_shared co-allocation)
```

The `std::atomic&lt;size_t&gt;` members require 8-byte alignment on x86_64. The two atomic fields
Together occupy a single 16-byte cache line, which is beneficial: concurrent increments and
Decrements of `strong_count` and `weak_count` contend on the same cache line rather than two
Separate ones.

When `std::make_shared` is used, the object is placed immediately after the control block:

```
make_shared<Sensor>(1) layout:
Offset  Size  Field
------  ----  -----
0x00    8     strong_count
0x08    8     weak_count
0x10    8     deleter (type-erased)
0x18    8     allocator (type-erased)
0x20    ?     Sensor object (placement new into trailing storage)
              ──────────────────────
              Total: 32 + sizeof(Sensor) (rounded up for alignment)
```

## 3.3 `std::make_shared` vs Direct Construction

```cpp
#include <memory>
#include <iostream>

struct Sensor {
    int id;
    Sensor(int i) : id(i) {
        std::cout << "Sensor(" << id << ") constructed\n";
    }
    ~Sensor() {
        std::cout << "Sensor(" << id << ") destroyed\n";
    }
};

void make_shared_demo() {
    // Single allocation: object + control block in one block
    auto p1 = std::make_shared<Sensor>(1);

    // Two allocations: object via new, control block separately
    std::shared_ptr<Sensor> p2(new Sensor(2));
}

void reference_counting_demo() {
    auto a = std::make_shared<Sensor>(3);
    std::cout << "use_count: " << a.use_count() << "\n";  // 1

    {
        auto b = a;  // Copy: increments strong_count
        std::cout << "use_count: " << a.use_count() << "\n";  // 2
    }
    // b destroyed, strong_count decremented

    std::cout << "use_count: " << a.use_count() << "\n";  // 1
}
// a destroyed, strong_count reaches 0, Sensor destroyed

Sensor(1) constructed
Sensor(2) constructed
Sensor(3) constructed
use_count: 1
use_count: 2
use_count: 1
Sensor(2) destroyed
Sensor(3) destroyed
Sensor(1) destroyed

make_shared (single allocation):
┌──────────┬─────────────────────────────────────┐
│ Sensor   │ Control Block (strong, weak, deleter)│
│ (object) │                                     │
└──────────┴─────────────────────────────────────┘
  One allocation, one free

shared_ptr(new Sensor) (two allocations):
┌──────────┐     ┌─────────────────────────────────────┐
│ Sensor   │     │ Control Block (strong, weak, deleter)│
│ (object) │     │                                     │
└──────────┘     └─────────────────────────────────────┘
  allocation 1         allocation 2
  Two allocations, two frees

#include <memory>
#include <thread>
#include <mutex>
#include <iostream>

struct Counter {
    int value = 0;
    std::mutex mtx;
};

void thread_safe_shared_ptr() {
    auto c = std::make_shared<Counter>();

    auto increment = [&c] {
        // This is safe: copying shared_ptr is atomic
        auto local = c;

        // This is safe: we lock the mutex before accessing the object
        std::lock_guard lock(local->mtx);
        local->value++;
    };

    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();

    std::cout << "value: " << c->value << "\n";  // 2
}

#include <memory>
#include <iostream>
#include <cstdio>

struct FileCloser {
    void operator()(FILE* f) const {
        if (f) {
            std::fclose(f);
            std::cout << "file closed\n";
        }
    }
};

void custom_deleter_demo() {
    // Custom deleter for C FILE*
    std::shared_ptr<FILE> file(std::fopen("/dev/null", "r"), FileCloser{});

    // Custom deleter with lambda
    std::shared_ptr<int> buffer(
        static_cast<int*>(std::malloc(100 * sizeof(int))),
        [](int* p) {
            std::free(p);
            std::cout << "buffer freed\n";
        }
    );

    // Custom deleter for array
    std::shared_ptr<char[]> str(new char[100], std::default_delete<char[]>());
}

#include <memory>
#include <iostream>

struct Person {
    std::string name;
    std::shared_ptr<Person> friend_;

    explicit Person(std::string n) : name(std::move(n)) {
        std::cout << name << " created\n";
    }
    ~Person() {
        std::cout << name << " destroyed\n";
    }
};

void circular_ref_leak() {
    auto alice = std::make_shared<Person>("Alice");
    auto bob = std::make_shared<Person>("Bob");

    alice->friend_ = bob;  // Bob's strong_count = 2
    bob->friend_ = alice;  // Alice's strong_count = 2

    // When alice and bob go out of scope:
    // Alice's strong_count: 2 → 1 (NOT zero, not destroyed)
    // Bob's strong_count: 2 → 1 (NOT zero, not destroyed)
    // MEMORY LEAK: neither is destroyed
}

Alice created
Bob created

#include <memory>
#include <iostream>
#include <string>
#include <vector>

class CowString {
    std::shared_ptr<std::vector<char>> data_;

    void detach() {
        if (!data_.unique()) {
            data_ = std::make_shared<std::vector<char>>(*data_);
            std::cout << "  (COW: detached copy)\n";
        }
    }

public:
    CowString(std::string s) {
        data_ = std::make_shared<std::vector<char>>(s.begin(), s.end());
    }

    // Copy is cheap — just shares the pointer
    CowString(const CowString& other) = default;

    char operator[](std::size_t i) const { return (*data_)[i]; }

    void set(std::size_t i, char c) {
        detach();  // Only copy if shared
        (*data_)[i] = c;
    }

    std::size_t ref_count() const { return data_.use_count(); }
    std::string str() const {
        return std::string(data_->begin(), data_->end());
    }
};

int main() {
    CowString a("hello");
    std::cout << "a ref_count: " << a.ref_count() << "\n";  // 1

    CowString b = a;  // Cheap copy, shares data
    std::cout << "b ref_count: " << b.ref_count() << "\n";  // 2

    // Reading does not detach
    std::cout << "a[0]: " << a[0] << "\n";  // h

    // Writing detaches because data is shared
    b.set(0, 'H');
    std::cout << "after write, a ref_count: " << a.ref_count() << "\n";  // 1
    std::cout << "a: " << a.str() << "\n";  // hello
    std::cout << "b: " << b.str() << "\n";  // Hello
}

#include <memory>
#include <iostream>

// Simplified std::enable_shared_from_this implementation
template<typename T>
class enable_shared_from_this {
    mutable std::weak_ptr<T> weak_this_;

    friend class std::shared_ptr<T>;

    // Called by the shared_ptr constructor after creating the control block
    void _internal_accept_owner(const std::shared_ptr<T>& owner) const {
        weak_this_ = owner;
    }

public:
    std::shared_ptr<T> shared_from_this() {
        return weak_this_.lock();
    }

    std::shared_ptr<const T> shared_from_this() const {
        return weak_this_.lock();
    }
};

#include <memory>
#include <iostream>
#include <string>

struct NetworkConnection : std::enable_shared_from_this<NetworkConnection> {
    std::string name;

    explicit NetworkConnection(std::string n) : name(std::move(n)) {
        std::cout << name << " constructed\n";
    }

    ~NetworkConnection() {
        std::cout << name << " destroyed\n";
    }

    // Safe: returns shared_ptr sharing the existing control block
    std::shared_ptr<NetworkConnection> get_self() {
        return shared_from_this();
    }

    void register_callback() {
        auto self = shared_from_this();
        // self keeps this object alive for the callback's lifetime
        std::cout << "  registered callback for " << self->name
                  << " (use_count=" << self.use_count() << ")\n";
    }
};

int main() {
    auto conn = std::make_shared<NetworkConnection>("tcp-42");
    std::cout << "initial use_count: " << conn.use_count() << "\n";  // 1

    auto self_ref = conn->get_self();
    std::cout << "after get_self: " << self_ref.use_count() << "\n";  // 2

    conn->register_callback();
    std::cout << "after register: " << conn.use_count() << "\n";  // back to 2
}

template<class Y>
shared_ptr(const shared_ptr<Y>& r, element_type* ptr) noexcept;

#include <memory>
#include <iostream>
#include <string>

struct Packet {
    std::string header;
    std::vector<char> payload;

    Packet(std::string h, std::vector<char> p)
        : header(std::move(h)), payload(std::move(p)) {}
};

void aliasing_example() {
    auto packet = std::make_shared<Packet>("HTTP/1.1 200 OK", {'d', 'a', 't', 'a'});

    // alias_ptr owns the Packet (via packet's control block)
    // but points to the payload vector
    std::shared_ptr<std::vector<char>> alias_ptr(packet, &packet->payload);

    std::cout << "packet use_count: " << packet.use_count() << "\n";    // 2
    std::cout << "alias use_count:  " << alias_ptr.use_count() << "\n";  // 2
    std::cout << "payload size:     " << alias_ptr->size() << "\n";      // 4

    // The Packet is destroyed when BOTH packet and alias_ptr are gone
    packet.reset();
    std::cout << "after packet.reset, alias use_count: " << alias_ptr.use_count() << "\n";  // 1
    std::cout << "payload still accessible: " << alias_ptr->size() << "\n";  // 4 (Packet alive)
}

#include <memory>
#include <iostream>

struct Resource {
    int id;
    explicit Resource(int i) : id(i) {
        std::cout << "Resource(" << id << ") acquired\n";
    }
    ~Resource() {
        std::cout << "Resource(" << id << ") released\n";
    }
};

int main() {
    // unique_ptr: zero overhead, exclusive ownership
    auto uptr = std::make_unique<Resource>(1);
    // auto uptr2 = uptr;           // ERROR: copy deleted
    auto uptr2 = std::move(uptr);   // OK: ownership transferred

    // shared_ptr: reference counted, copyable
    auto sptr = std::make_shared<Resource>(2);
    auto sptr2 = sptr;              // OK: reference count incremented
    std::cout << "use_count: " << sptr.use_count() << "\n";  // 2
}