Smart Pointers

Chapter 1: std::unique_ptr

std::unique_ptr embodies exclusive ownership. It's the same size as a raw pointer, executes the same instructions for dereferencing, and should be your default smart pointer. When a unique_ptr is destroyed, it deletes the resource it owns.

Moving a unique_ptr transfers ownership. Copying is not allowed — if you could copy it, two unique_ptrs would think they each own the resource.

c++
// Factory function returning unique_ptr (Item 18 pattern)
class Investment { public: virtual ~Investment(); };
class Stock : public Investment { };
class Bond  : public Investment { };

template<typename... Ts>
std::unique_ptr<Investment> makeInvestment(Ts&&... params) {
    // create the right derived type, return as base unique_ptr
    auto deleter = [](auto* p) { log(p); delete p; };
    // ... (factory logic)
}

auto pInv = makeInvestment(/* args */);
// pInv destroyed here: Investment is automatically deleted

A key feature: unique_ptr easily converts to shared_ptr, making it ideal for factory return types. Callers get exclusive ownership by default but can upgrade to shared ownership if needed.

Chapter 2: std::shared_ptr

shared_ptr provides shared ownership through reference counting. When the last shared_ptr to a resource is destroyed, the resource is deleted. The cost? A shared_ptr is twice the size of a raw pointer (it stores a pointer to the resource and a pointer to the control block).

c++
// DANGER: two control blocks for the same object!
auto pw = new Widget;
std::shared_ptr<Widget> spw1(pw, loggingDel);
std::shared_ptr<Widget> spw2(pw, loggingDel);  // double-free!

Chapter 3: std::weak_ptr

Sometimes you need a pointer that acts like a shared_ptr but doesn't participate in ownership. weak_ptr is that pointer: it can observe a shared_ptr-managed resource without affecting its reference count.

c++
auto spw = std::make_shared<Widget>();  // ref count = 1
std::weak_ptr<Widget> wpw(spw);         // ref count still 1

spw = nullptr;  // ref count = 0, Widget destroyed

if (wpw.expired()) { /* Widget is gone */ }

// Safe access: lock() returns shared_ptr (null if expired)
auto spw2 = wpw.lock();
if (spw2) { /* use *spw2 safely */ }

c++
// Caching factory pattern
std::shared_ptr<Widget> fastLoadWidget(WidgetID id) {
    static std::unordered_map<WidgetID, std::weak_ptr<Widget>> cache;
    auto sp = cache[id].lock();  // try to get existing
    if (!sp) {
        sp = loadWidget(id);     // not cached: load it
        cache[id] = sp;            // cache a weak_ptr
    }
    return sp;
}

Chapter 4: Prefer make Functions

std::make_shared and std::make_unique (C++14) should be preferred over direct use of new for three reasons:

c++
// Direct new: type name written twice
auto upw1(std::unique_ptr<Widget>(new Widget));
auto spw1(std::shared_ptr<Widget>(new Widget));

// make functions: type name once, exception safe
auto upw2 = std::make_unique<Widget>();
auto spw2 = std::make_shared<Widget>();

When you can't use make functions: (1) custom deleters (make functions don't support them), (2) braced initializers (make functions use parentheses internally), (3) classes with custom operator new/delete, and (4) when weak_ptrs outlive shared_ptrs (make_shared's single allocation means the memory isn't freed until the last weak_ptr dies).

Chapter 5: The Pimpl Idiom

The Pimpl (Pointer to IMPLementation) idiom hides a class's data members behind a pointer to a forward-declared implementation struct. This reduces compilation dependencies — changes to the implementation don't force recompilation of clients.

widget.h
class Widget {
public:
    Widget();
    ~Widget();                          // must be declared!
    Widget(Widget&&);                  // must be declared!
    Widget& operator=(Widget&&);       // must be declared!
private:
    struct Impl;                       // forward declaration only
    std::unique_ptr<Impl> pImpl;       // pointer to incomplete type
};

widget.cpp
struct Widget::Impl {
    std::string name;
    std::vector<Gadget> gadgets;
    // all the heavy headers stay here
};

Widget::Widget() : pImpl(std::make_unique<Impl>()) {}
Widget::~Widget() = default;          // defined where Impl is complete
Widget::Widget(Widget&&) = default;
Widget& Widget::operator=(Widget&&) = default;

With shared_ptr, this isn't necessary — the deleter isn't part of the type, so the pointed-to type doesn't need to be complete at the point of destruction. But unique_ptr is the right choice here (exclusive ownership), so you pay the small cost of declaring special members.

Chapter 6: Ownership Decision Lab

Which smart pointer should you reach for? Click each scenario to see the recommendation.

Chapter 7: Beyond

"When you reach for a smart pointer, std::unique_ptr should generally be the one closest at hand." — Scott Meyers