Smart Pointers in C++: unique_ptr and shared_ptr

C++ inherits raw pointers and manual memory management from C, with new and delete in place of malloc and free. Forgetting a delete leaks memory; deleting twice crashes. Modern C++ solves this with smart pointers: objects that own heap memory and free it automatically (RAII). In modern code you should almost never write delete.

new and delete

#include <iostream>

int main() {
    int* p = new int(42);              // one int on the heap
    int* arr = new int[5]{1, 2, 3, 4, 5};   // an array on the heap

    std::cout << *p << ' ' << arr[4] << '\n';

    delete p;                          // free a single object
    delete[] arr;                      // free an array: must use delete[]
    p = nullptr;                       // nullptr, not NULL, in C++
    return 0;
}

42 5

unique_ptr: one owner

#include <iostream>
#include <memory>
#include <string>
#include <utility>

struct Document {
    std::string title;
    explicit Document(std::string t) : title(std::move(t)) { std::cout << "open " << title << '\n'; }
    ~Document() { std::cout << "close " << title << '\n'; }
};

std::unique_ptr<Document> create(const std::string& name) {
    return std::make_unique<Document>(name);      // ownership moves to the caller
}

int main() {
    auto report = create("report.pdf");
    std::cout << "editing " << report->title << '\n';

    // auto copy = report;                         // error: unique_ptr can't be copied
    auto owner = std::move(report);                // ownership transferred
    std::cout << "report is " << (report ? "set" : "empty") << ", owner has " << owner->title << '\n';

    {
        auto temp = std::make_unique<Document>("temp.txt");
    }                                              // temp closed here automatically
    std::cout << "end of main\n";
    return 0;
}                                                  // owner closed here

open report.pdf
editing report.pdf
report is empty, owner has report.pdf
open temp.txt
close temp.txt
end of main
close report.pdf

unique_ptr has the same size and speed as a raw pointer, but deletes its object when it goes out of scope. It can't be copied – only moved – so there's always exactly one owner. It should be your default choice.

shared_ptr: shared ownership

#include <iostream>
#include <memory>
#include <string>
#include <vector>

struct Image {
    std::string file;
    explicit Image(std::string f) : file(std::move(f)) {}
    ~Image() { std::cout << "freed " << file << '\n'; }
};

int main() {
    auto logo = std::make_shared<Image>("logo.png");
    std::cout << "owners: " << logo.use_count() << '\n';
    {
        std::vector<std::shared_ptr<Image>> pages{logo, logo, logo};   // three more owners
        std::cout << "owners: " << logo.use_count() << '\n';
    }                                                      // the vector's copies are released
    std::cout << "owners: " << logo.use_count() << '\n';
    logo.reset();                                          // last owner gone → object freed
    std::cout << "done\n";
    return 0;
}

owners: 1
owners: 4
owners: 1
freed logo.png
done

weak_ptr: observing without owning

#include <iostream>
#include <memory>

struct Node {
    int value;
    std::shared_ptr<Node> next;        // owns the next node
    std::weak_ptr<Node> prev;          // doesn't own: avoids a reference cycle
    explicit Node(int v) : value(v) {}
    ~Node() { std::cout << "node " << value << " freed\n"; }
};

int main() {
    auto a = std::make_shared<Node>(1);
    auto b = std::make_shared<Node>(2);
    a->next = b;
    b->prev = a;
    if (auto p = b->prev.lock()) {     // lock() gives a shared_ptr if the object still exists
        std::cout << "b's previous node is " << p->value << '\n';
    }
    return 0;
}                                      // both nodes freed: no cycle of shared_ptrs

b's previous node is 1
node 1 freed
node 2 freed

If prev were a shared_ptr, a and b would own each other, their counts would never reach zero, and both would leak. weak_ptr breaks such cycles – common in trees with parent links, caches and observer patterns.

Which pointer?

Practice

Summary