Smart Pointers

Smart pointers are RAII applied to heap memory. They own a pointer and delete it automatically when they go out of scope. They are the reason modern C++ almost never leaks. All live in <memory>.

unique_ptr — sole ownership

A unique_ptr owns its object exclusively. It cannot be copied (that would mean two owners), only moved (ownership transfers). When it dies, it deletes. Zero runtime overhead versus a raw pointer — it's the default choice.

#include <memory>

auto p = std::make_unique<int>(42);   // allocates, owns an int(42)
std::cout << *p;                        // use like a normal pointer
// auto q = p;                         // ERROR: cannot copy a unique_ptr
auto q = std::move(p);                 // OK: ownership moves to q; p is now null
// no delete needed — freed automatically when the owner dies

shared_ptr — shared ownership

A shared_ptr lets multiple owners share one object. It keeps a reference count; the object is deleted when the last shared_ptr is destroyed. It costs more than unique_ptr (atomic counter updates), so use it only when ownership is genuinely shared.

auto a = std::make_shared<int>(7);  // ref count = 1
{
    auto b = a;                        // ref count = 2 (b shares ownership)
}                                      // b dies, ref count = 1
// object freed when a dies and count hits 0

weak_ptr — non-owning observer

A weak_ptr observes a shared_ptr's object without owning it — it doesn't affect the reference count. You lock() it to get a temporary shared_ptr if the object still exists. Its main job is breaking reference cycles.

Always prefer the make_ functions

// GOOD
auto p = std::make_unique<Widget>(args);
auto s = std::make_shared<Widget>(args);

// AVOID: naked new is exception-unsafe in some call contexts and more verbose
std::unique_ptr<Widget> p2(new Widget(args));

make_shared also allocates the object and its control block together, which is faster and cache-friendlier.