Smart Pointers in Modern C++

For decades, C++ memory management meant pairing every new with a delete — and hoping you never forgot one, never deleted twice, and never left a pointer dangling after the memory was freed. Smart pointers, introduced properly with C++11, largely ended that manual bookkeeping.

The Problem They Solve

cpp
Copy
void oldWay() {
    int* data = new int(42);
    // ... if an exception is thrown here, or you forget delete below,
    // this memory is leaked forever ...
    delete data;
}

Every manual new/delete pair is a place a memory leak, a double-free, or a dangling pointer can sneak in — especially once exceptions and early returns are involved. Smart pointers apply RAII (see the constructors/destructors post) to memory itself: the object's destructor automatically frees the memory, so there's no manual delete to forget.

unique_ptr — Exclusive Ownership

std::unique_ptr owns its memory exclusively. No two unique_ptrs can point to the same object — ownership can be transferred, but never shared.

cpp
Copy
#include <memory>
 
std::unique_ptr<int> ptr = std::make_unique<int>(42);
std::cout << *ptr;   // 42
 
// std::unique_ptr<int> ptr2 = ptr;      // compile error — can't copy
std::unique_ptr<int> ptr2 = std::move(ptr);  // ownership transferred; ptr is now empty

When ptr2 goes out of scope, the memory is freed automatically — no delete needed anywhere. This should be your default choice whenever an object has one clear owner.

shared_ptr — Shared Ownership

std::shared_ptr allows multiple pointers to jointly own the same object, using an internal reference count. The memory is only freed once the last shared_ptr pointing to it is destroyed.

cpp
Copy
std::shared_ptr<int> a = std::make_shared<int>(100);
std::shared_ptr<int> b = a;   // both now share ownership; ref count = 2
 
std::cout << a.use_count();    // 2

Use this when an object genuinely needs multiple independent owners — for example, a resource shared across several parts of a program where no single part is clearly responsible for cleanup.

weak_ptr — Observing Without Owning

std::weak_ptr points to an object managed by a shared_ptr without increasing the reference count. It exists to solve one specific problem: circular references.

cpp
Copy
struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev;   // weak — breaks the cycle
};

If two objects hold shared_ptrs to each other, their reference counts never reach zero, and neither is ever freed — a memory leak despite using "smart" pointers. Making one direction weak_ptr breaks that cycle, since it doesn't count toward ownership.

cpp
Copy
std::shared_ptr<int> sp = std::make_shared<int>(10);
std::weak_ptr<int> wp = sp;
 
if (auto locked = wp.lock()) {     // safely check if it's still alive
    std::cout << *locked;
}

Choosing the Right One

A common rule of thumb: reach for unique_ptr by default, upgrade to shared_ptr only when shared ownership is a real requirement, and use weak_ptr specifically to break cycles or to safely check whether a shared object still exists.

The Takeaway

Smart pointers turn memory management from a manual discipline into something the type system enforces for you. unique_ptr gives you safe exclusive ownership at zero extra cost, shared_ptr handles genuinely shared resources with automatic cleanup, and weak_ptr quietly solves the one problem shared ownership creates on its own — reference cycles that would otherwise leak forever.