📝 Lesson 10: Smart Pointers

Why Smart Pointers?

Smart pointers are like responsible pet owners - they automatically take care of their resources, feeding them when needed and cleaning up after them. No more memory leaks or dangling pointers!

The Smart Pointer Family

unique_ptr: Exclusive Ownership

unique_ptr is like having a single key to a house - only one person can own it at a time. When they're done, the house is automatically sold (memory freed)!

unique_ptr Examples

#include <memory>
#include <iostream>
using namespace std;

// Basic unique_ptr usage
void uniquePtrBasics() {
    // Creating unique_ptr
    unique_ptr<int> p1(new int(42));           // Direct initialization
    auto p2 = make_unique<int>(42);            // Preferred: make_unique

    // Accessing the value
    cout << *p2 << endl;                       // Dereference: 42
    cout << p2.get() << endl;                  // Get raw pointer

    // unique_ptr with arrays
    auto arr = make_unique<int[]>(10);         // Array of 10 ints
    arr[0] = 100;

    // Custom deleter
    auto fileDeleter = [](FILE* f) {
        if (f) fclose(f);
    };
    unique_ptr<FILE, decltype(fileDeleter)> file(
        fopen("data.txt", "r"), fileDeleter
    );
}

// Ownership transfer
unique_ptr<string> createMessage() {
    auto msg = make_unique<string>("Hello from function!");
    return msg;  // Automatic move
}

void transferOwnership() {
    auto p1 = make_unique<int>(42);
    // unique_ptr<int> p2 = p1;             // ERROR: Can't copy
    unique_ptr<int> p2 = move(p1);         // OK: Move ownership

    if (!p1) {
        cout << "p1 is now null" << endl;
    }

    // Reset and release
    p2.reset();                             // Delete object, set to null
    p2.reset(new int(100));                 // Delete old, own new

    int* raw = p2.release();                // Release ownership
    delete raw;                             // Now we must delete manually
}

// Using unique_ptr in classes
class Resource {
private:
    unique_ptr<int[]> data;
    size_t size;

public:
    Resource(size_t n) : data(make_unique<int[]>(n)), size(n) {
        // Initialize array
        for (size_t i = 0; i < size; ++i) {
            data[i] = i;
        }
    }

    // No need for destructor - unique_ptr handles it!
    // No need for copy constructor/assignment - deleted by default

    // Move constructor (compiler-generated is fine)
    Resource(Resource&&) = default;
    Resource& operator=(Resource&&) = default;

    int& operator[](size_t i) { return data[i]; }
};

shared_ptr: Shared Ownership

shared_ptr is like a shared apartment - multiple roommates can have keys. The apartment is only sold when the last roommate moves out!

shared_ptr Examples

// Basic shared_ptr usage
void sharedPtrBasics() {
    // Creating shared_ptr
    shared_ptr<int> sp1(new int(42));           // Direct
    auto sp2 = make_shared<int>(42);            // Preferred: more efficient

    // Copying increases reference count
    shared_ptr<int> sp3 = sp2;                  // Count: 2
    {
        shared_ptr<int> sp4 = sp2;              // Count: 3
    }                                            // Count: 2 (sp4 destroyed)

    // Check reference count
    cout << "Use count: " << sp2.use_count() << endl;

    // Check if unique owner
    // Note: sp.unique() was deprecated in C++17 and removed in C++20 —
    // compare the use count instead.
    if (sp1.use_count() == 1) {
        cout << "sp1 is the only owner" << endl;
    }
}

// Circular reference problem
class Node {
public:
    int value;
    shared_ptr<Node> next;
    shared_ptr<Node> prev;    // Creates cycle!

    Node(int val) : value(val) {
        cout << "Node " << value << " created" << endl;
    }

    ~Node() {
        cout << "Node " << value << " destroyed" << endl;
    }
};

void circularReferenceProblem() {
    auto node1 = make_shared<Node>(1);
    auto node2 = make_shared<Node>(2);

    node1->next = node2;
    node2->prev = node1;    // Circular reference!

    // When function ends, nodes are NOT destroyed
    // Reference count never reaches 0
}

// Solution: Use weak_ptr
class SafeNode {
public:
    int value;
    shared_ptr<SafeNode> next;
    weak_ptr<SafeNode> prev;    // Weak reference breaks cycle

    SafeNode(int val) : value(val) {}
};

// Custom deleter with shared_ptr
void customDeleterExample() {
    auto arrayDeleter = [](int* p) {
        cout << "Deleting array" << endl;
        delete[] p;
    };

    shared_ptr<int> sp(new int[10], arrayDeleter);

    // Or use default_delete for arrays
    shared_ptr<int[]> arr(new int[10]);
}

// Aliasing constructor
struct Person {
    string name;
    int age;
};

void aliasingExample() {
    auto person = make_shared<Person>(Person{"Alice", 30});

    // Create shared_ptr to member
    shared_ptr<string> namePtr(person, &person->name);

    // namePtr keeps person alive even if person goes out of scope
}

weak_ptr: Breaking Cycles

weak_ptr is like having a business card - you can call the number to check if the business still exists, but the card itself doesn't keep the business running!

weak_ptr Examples

// Basic weak_ptr usage
void weakPtrBasics() {
    shared_ptr<int> sp = make_shared<int>(42);
    weak_ptr<int> wp = sp;                      // Create weak_ptr

    // Check if still valid
    if (!wp.expired()) {
        // Convert to shared_ptr to use
        if (auto locked = wp.lock()) {
            cout << "Value: " << *locked << endl;
            // locked keeps object alive in this scope
        }
    }

    sp.reset();                                  // Destroy object

    if (wp.expired()) {
        cout << "Object has been destroyed" << endl;
    }
}

// Observer pattern with weak_ptr
class Subject;

class Observer {
private:
    weak_ptr<Subject> subject;

public:
    void observe(shared_ptr<Subject> s) {
        subject = s;
    }

    void update() {
        if (auto s = subject.lock()) {
            // Subject still exists, can safely use
            cout << "Updating based on subject" << endl;
        } else {
            cout << "Subject has been destroyed" << endl;
        }
    }
};

Smart Pointer Best Practices

Common Pitfalls and Solutions

Performance Considerations

// Performance comparison
class PerformanceDemo {
public:
    // unique_ptr: Zero overhead
    void uniquePtrPerf() {
        unique_ptr<int> up(new int(42));
        // Same performance as raw pointer
        // No reference counting
        // Inline destructor
    }

    // shared_ptr: Reference counting overhead
    void sharedPtrPerf() {
        shared_ptr<int> sp(new int(42));
        // Atomic reference counting (thread-safe)
        // Control block allocation
        // Virtual destructor call
    }

    // make_shared optimization
    void makeSharedOptimization() {
        // Two allocations: object + control block
        shared_ptr<int> sp1(new int(42));

        // Single allocation: object + control block together
        auto sp2 = make_shared<int>(42);  // More cache-friendly
    }

    // Moving vs copying
    void moveVsCopy() {
        auto sp1 = make_shared<LargeObject>();

        // Copying: Atomic increment/decrement
        shared_ptr<LargeObject> sp2 = sp1;          // Slower

        // Moving: No atomic operations
        shared_ptr<LargeObject> sp3 = move(sp1);    // Faster
    }
};

💡 Smart pointers can also use custom allocators (for example pooled allocation via allocate_shared) in performance-critical code — a generic technique that builds on Templates (Lesson 15) and the STL (Lesson 16).

Practice Exercise: Resource Manager

#include <iostream>
#include <memory>
#include <string>
using namespace std;

class Resource {
    string name;
public:
    Resource(string n) : name(n) { cout << "Created " << name << '\n'; }
    ~Resource()                  { cout << "Destroyed " << name << '\n'; }
    void use() { cout << "Using " << name << '\n'; }
};

int main() {
    // TODO: unique_ptr in a scope
    // TODO: shared_ptr + a second owner, print use_count()
    // TODO: weak_ptr, lock(), expired()
    return 0;
}

#include <iostream>
#include <memory>
#include <string>
using namespace std;

class Resource {
    string name;
public:
    Resource(string n) : name(n) { cout << "Created " << name << '\n'; }
    ~Resource()                  { cout << "Destroyed " << name << '\n'; }
    void use() { cout << "Using " << name << '\n'; }
};

int main() {
    // unique_ptr — exclusive ownership, auto-freed at scope end
    {
        auto u = make_unique<Resource>("Unique");
        u->use();
    } // "Destroyed Unique" prints here

    // shared_ptr — shared ownership, freed when the last owner goes
    weak_ptr<Resource> observer;
    {
        auto s1 = make_shared<Resource>("Shared");
        auto s2 = s1;                                    // second owner
        cout << "use_count = " << s1.use_count() << '\n'; // 2
        observer = s1;                                   // weak_ptr adds no owner
        cout << "use_count = " << s1.use_count() << '\n'; // still 2

        if (auto locked = observer.lock())               // temporary owner
            locked->use();
    } // both s1 and s2 gone -> "Destroyed Shared" prints here

    cout << "expired? " << observer.expired() << '\n';    // 1 (true)
    return 0;
}

Looking Ahead: Smart Pointers in Containers

The three smart pointers you just learned become even more powerful once you can store many objects at once and model relationships between types — a pairing you'll unlock in later lessons. Here's a preview of where they lead:

Modern C++ Features

Challenge Exercise: Memory Pool

#include <iostream>
#include <memory>
using namespace std;

struct Child;                     // forward declaration

struct Parent {
    shared_ptr<Child> child;
    ~Parent() { cout << "Parent destroyed\n"; }
};

struct Child {
    weak_ptr<Parent> parent;       // weak_ptr breaks the cycle (was shared_ptr)
    ~Child() { cout << "Child destroyed\n"; }
};

int main() {
    {
        auto p = make_shared<Parent>();
        auto c = make_shared<Child>();
        p->child  = c;            // Parent owns Child
        c->parent = p;            // Child only observes Parent (weak)
    } // both destructors run here

    cout << "Done\n";
    return 0;
}

🎯 Quick Quiz

Summary

📚 Additional Resources

• cppreference.com
• cppreference — std::unique_ptr
• cppreference — std::shared_ptr

🚀 What's Next?

You've now mastered modern C++ memory management with smart pointers and RAII. Next, in Lesson 11: Inheritance and Polymorphism, you'll relate your classes to one another — letting one type extend another and letting a single interface behave differently depending on the actual object behind it (often held through the very pointers you just learned to manage safely).