DDyynnaammiicc MMeemmoorryy

// ── new / delete — single object ─────────────────────────────
int* p = new int(42);   // allocate + initialize
*p;                      // 42
delete p;                // release memory
p = nullptr;             // good practice: null after delete

// ── new[] / delete[] — arrays ────────────────────────────────
int* arr = new int[10]{};   // 10 zero-initialized ints
arr[0] = 5;
delete[] arr;               // must use delete[], not delete

// ── Placement new — construct into existing memory ────────────
alignas(int) char buf[sizeof(int)];
int* p2 = new (buf) int(99);   // constructs in buf — no heap alloc
p2->~int();                     // must call destructor manually

// ── operator new / operator delete — raw allocation ──────────
void* raw = ::operator new(sizeof(MyClass));
MyClass* obj = new (raw) MyClass(args);
obj->~MyClass();
::operator delete(raw);

// ⚠ new throws std::bad_alloc if allocation fails
// Use new (std::nothrow) T to get nullptr instead of exception
int* safe = new (std::nothrow) int(5);
if (!safe) { /* handle OOM */ }

#include <memory>

// ── unique_ptr — sole ownership, zero overhead ───────────────
auto p = std::make_unique<int>(42);   // preferred — exception safe
*p;            // 42
p.get();       // raw int* (non-owning)
p.reset();     // destroy object; p becomes null
p = nullptr;   // same as reset()

// Transfer ownership — source becomes null
auto q = std::move(p);   // p=null, q owns the int

// unique_ptr for arrays
auto arr = std::make_unique<int[]>(10);
arr[5] = 99;   // operator[] defined for array form

// Custom deleter
auto file = std::unique_ptr<FILE, decltype(&fclose)>(
  fopen("data.txt", "r"), fclose);  // fclose called on destruction

// ── Returning from a factory ──────────────────────────────────
std::unique_ptr<Shape> makeShape(std::string_view type) {
  if (type == "circle")  return std::make_unique<Circle>(5.0);
  if (type == "square")  return std::make_unique<Square>(3.0);
  return nullptr;
}

auto shape = makeShape("circle");
shape->area();   // virtual dispatch still works through unique_ptr

#include <memory>

// ── shared_ptr — shared ownership via reference count ────────
auto s1 = std::make_shared<int>(10);  // count=1
auto s2 = s1;                          // count=2  (copy)
auto s3 = s1;                          // count=3
s1.use_count();   // 3

s1.reset();       // count=2; object still alive
s2.reset();       // count=1
s3.reset();       // count=0 → object destroyed

// shared_ptr is copyable — unique_ptr is not
void register(std::shared_ptr<Widget> w) { cache.push_back(w); }

// ── make_shared vs new ────────────────────────────────────────
// make_shared: one allocation for object + control block (faster)
auto good = std::make_shared<int>(5);    // ✅ single alloc
// shared_ptr<int> bad(new int(5));      // ⚠ two allocs

// ── Circular reference — memory leak! ────────────────────────
struct Node {
  std::shared_ptr<Node> next;  // ❌ if two nodes point to each other,
};                              //    neither ref count reaches zero

#include <memory>

// weak_ptr — non-owning observer of a shared_ptr
// Doesn't increment the reference count
// Must be "locked" to use — returns null if object was destroyed

struct Cache {
  std::weak_ptr<Resource> cached;

  std::shared_ptr<Resource> get() {
    if (auto r = cached.lock()) {  // lock() → shared_ptr or null
      return r;   // object still alive
    }
    return nullptr;  // object was destroyed
  }
};

// ── Breaking circular references ──────────────────────────────
struct Node {
  std::shared_ptr<Node> next;
  std::weak_ptr<Node>   prev;   // ✅ weak breaks the cycle
};

// ── Observer pattern ──────────────────────────────────────────
class EventSource {
  std::vector<std::weak_ptr<Listener>> listeners_;
public:
  void notify() {
    listeners_.erase(
      std::remove_if(listeners_.begin(), listeners_.end(),
        [](auto& w){ return w.expired(); }),
      listeners_.end());
    for (auto& w : listeners_)
      if (auto l = w.lock()) l->onEvent();
  }
};

// ── The ownership decision tree ──────────────────────────────

// Is the object shared between multiple owners?
//   Yes → shared_ptr<T>
//   No  → unique_ptr<T>  (or stack allocation if small + short-lived)

// Do you need a non-owning reference to a shared object?
//   → weak_ptr<T> (safe, checks if alive)
//   → raw T*      (unsafe, only if lifetime is well-known)

// Is the object large or needs to outlive the current scope?
//   → heap allocation (unique_ptr or shared_ptr)
//   Otherwise → stack or member variable

// ── When raw new/delete is acceptable ────────────────────────
// 1. Inside a custom smart pointer or container (you're building RAII)
// 2. Placement new for custom memory management
// 3. Rare performance-critical code after profiling
// ⚠ Never: raw new in application code where a smart pointer works

// ── Summary ───────────────────────────────────────────────────
// unique_ptr → 95% of heap allocation needs
// shared_ptr → shared ownership between components
// weak_ptr   → caches, observers, cycle-breaking
// raw ptr    → non-owning views only

// ── Stack allocation (no heap at all) ────────────────────────
int arr[1000];        // 4 KB on the stack — instant, no overhead
std::array<int,1000> a; // same, with bounds checking

// ── Custom allocator (advanced) ───────────────────────────────
// Standard containers accept an allocator as the second template param
// Useful for: arenas, pools, logging allocation, embedded systems

// ── Object pool — reuse fixed-size blocks ─────────────────────
template<typename T, std::size_t N>
class Pool {
  alignas(T) char storage_[N * sizeof(T)];
  std::stack<T*> free_;
public:
  Pool() {
    for (std::size_t i = 0; i < N; i++)
      free_.push(reinterpret_cast<T*>(storage_) + i);
  }
  T* alloc() { auto p = free_.top(); free_.pop(); return p; }
  void free(T* p) { p->~T(); free_.push(p); }
};

// ── std::pmr (C++17) — polymorphic memory resources ──────────
#include <memory_resource>
std::pmr::monotonic_buffer_resource pool(1024);
std::pmr::vector<int> v{&pool};   // v allocates from pool, no heap