C++ Smart Pointers Cheat Sheet

#include <memory>std::unique_ptr<int> p = std::make_unique<int>(42);  // preferred over newstd::cout << *p;std::unique_ptr<int> p2 = std::move(p);   // ownership transferred, p is now null// std::unique_ptr<int> p3 = p2;          // compile error: copying is disabledvoid takeOwnership(std::unique_ptr<int> ptr) { /* ... */ }takeOwnership(std::move(p2));             // must move, cannot copy// custom deleterstd::unique_ptr<FILE, decltype(&fclose)> file(fopen("f.txt", "r"), &fclose);

std::shared_ptr<int> a = std::make_shared<int>(10);  // preferred: single allocationstd::shared_ptr<int> b = a;      // both share ownership, use_count() == 2std::cout << a.use_count();      // 2a.reset();                        // a releases its reference; count -> 1// object is destroyed only when the last shared_ptr is destroyed/resetstd::shared_ptr<int> c(new int(5), [](int* p) {    std::cout << "custom delete\n";    delete p;});

std::shared_ptr<int> sp = std::make_shared<int>(99);std::weak_ptr<int> wp = sp;       // does not increase use_countif (auto locked = wp.lock()) {    // returns a shared_ptr, or nullptr if expired    std::cout << *locked;} else {    std::cout << "expired";}std::cout << wp.expired();        // true if the managed object was already destroyed

struct Node {    std::shared_ptr<Node> next;    std::weak_ptr<Node> prev;    // weak_ptr breaks the cycle};auto a = std::make_shared<Node>();auto b = std::make_shared<Node>();a->next = b;b->prev = a;   // if this were shared_ptr, a and b would leak forever

class Session : public std::enable_shared_from_this<Session> {public:    std::shared_ptr<Session> getShared() {        return shared_from_this();   // shares the SAME control block as the original    }    void registerCallback(std::function<void()>& cb) {        // capture a shared_ptr, not 'this', so the object outlives the async op        cb = [self = shared_from_this()] { self->onEvent(); };    }    void onEvent() { /* ... */ }};// WRONG: calling shared_from_this() before any shared_ptr owns the object throws// std::bad_weak_ptr - the object must already be managed via make_shared.

struct Widget { int id; std::string name; };auto owner = std::make_shared<Widget>(Widget{1, "gizmo"});// aliasing constructor: keeps 'owner's control block alive, but *points* at &owner->namestd::shared_ptr<std::string> namePtr(owner, &owner->name);owner.reset();               // Widget is NOT destroyed yet -std::cout << *namePtr;       // namePtr still keeps it alive; prints "gizmo"// common use: exposing a member of a pimpl-managed object without exposing the whole type

// array specialization calls delete[] automaticallystd::unique_ptr<int[]> arr = std::make_unique<int[]>(10);arr[3] = 42;// storing a derived object through a unique_ptr<Base> REQUIRES a virtual destructor,// otherwise only Base::~Base runs and Derived's resources leakstruct Base { virtual ~Base() = default; };struct Derived : Base { std::vector<int> data{1, 2, 3}; };std::unique_ptr<Base> p = std::make_unique<Derived>();p.reset();   // safe: virtual dtor ensures ~Derived runs first// covariant return with unique_ptr (C++14+)struct Cloneable { virtual std::unique_ptr<Cloneable> clone() const = 0; virtual ~Cloneable() = default; };

// make_shared allocates ONE block: [control block | T object] contiguouslyauto sp = std::make_shared<int>(5);// shared_ptr(new T(...)) allocates TWO separate blocks: object, then control blockstd::shared_ptr<int> sp2(new int(5));   // extra allocation + worse cache locality// gotcha: with make_shared, the T's memory is NOT freed until the control block// itself is freed - i.e. until the LAST weak_ptr also disappears, not just the// last shared_ptr. A long-lived weak_ptr can keep a large object's memory pinned.std::weak_ptr<int> wp = sp;sp.reset();          // int's destructor runs now...// ...but the underlying storage for the control block + int stays allocated// until wp itself is destroyed, because they share one allocation.