Smart Pointers

🎒 Smart Pointers: Your Memory Bodyguards

The Story of the Forgetful Toy Collector

Imagine you have a friend named Charlie who loves collecting toys. But Charlie has a problem—he keeps forgetting to put toys back on the shelf!

Toys pile up everywhere. The room gets messy. Eventually, there’s no space left to play. 😱

In C++, memory is like Charlie’s room. When you create things (objects), they take up space. If you forget to clean up, your program runs out of memory. This is called a memory leak.

Smart pointers are like helpful robots that automatically put toys back when you’re done playing. No more forgetting! 🤖✨

🧸 The Three Robot Helpers

C++ gives you three special robots (smart pointers) to manage your toys (memory):

Let’s meet each one!

🏆 unique_ptr: The Solo Guardian

What Is It?

unique_ptr is like a toy that only ONE child can own. If you want to give it to someone else, you must hand it over completely—you can’t keep a copy!

The Simple Rule

One toy, one owner. Period.

Creating Your First unique_ptr

#include <memory>

// The OLD way (dangerous!)
int* old_ptr = new int(42);
// You MUST remember: delete old_ptr;

// The NEW way (safe!)
std::unique_ptr<int> smart_ptr =
    std::make_unique<int>(42);
// Automatic cleanup! 🎉

Why make_unique?

Think of make_unique as a toy factory that:

1. Creates the toy
2. Puts it in a safe box
3. Hands you the box

// ✅ GOOD: Use make_unique
auto toy = std::make_unique<Robot>();

// ❌ OLD: Avoid this pattern
std::unique_ptr<Robot> toy(new Robot());

Real Example: A Game Character

#include <memory>
#include <string>

class Hero {
public:
    std::string name;
    int health = 100;

    Hero(std::string n) : name(n) {
        // Hero is born!
    }
    ~Hero() {
        // Hero says goodbye
    }
};

int main() {
    // Create a hero
    auto hero = std::make_unique<Hero>("Luna");

    // Use the hero
    hero->health -= 10;

    // When main() ends...
    // hero is automatically deleted! ✨
}

Moving a unique_ptr

You can transfer ownership, but not copy:

auto toy = std::make_unique<Robot>();

// ❌ ERROR: Can't copy!
// auto toy2 = toy;

// ✅ OK: Move ownership
auto toy2 = std::move(toy);
// Now toy is empty (nullptr)
// toy2 owns the robot

graph TD
    A["toy owns Robot"] --> B["std::move"]
    B --> C["toy2 owns Robot"]
    B --> D["toy is now empty"]

🤝 shared_ptr: The Friendship Circle

What Is It?

shared_ptr is like a toy that friends can share. Everyone can play with it. The toy only gets put away when the last friend stops playing.

The Simple Rule

Count the friends. When count hits zero, cleanup time!

How It Works

#include <memory>

// Create a shared toy
auto toy = std::make_shared<Robot>();
// Reference count: 1

{
    auto friend1 = toy; // count: 2
    auto friend2 = toy; // count: 3
    // friend1 and friend2 go away
} // count drops to 1

// toy still exists!
// When toy goes away -> count: 0 -> deleted

Visual: Reference Counting

graph TD
    subgraph "Reference Count = 3"
        TOY["🤖 Robot"]
        P1["ptr1"] --> TOY
        P2["ptr2"] --> TOY
        P3["ptr3"] --> TOY
    end

make_shared vs new

// ✅ BEST: One memory allocation
auto ptr = std::make_shared<Widget>();

// ❌ AVOID: Two allocations
std::shared_ptr<Widget> ptr(new Widget());

Why? make_shared is:

• Faster (one allocation, not two)
• Safer (no memory leak if exception)
• Cleaner (less typing)

Real Example: Game Party System

#include <memory>
#include <vector>

class Treasure {
public:
    int gold = 100;
};

class Player {
public:
    std::shared_ptr<Treasure> loot;
};

int main() {
    // Party finds treasure together
    auto chest = std::make_shared<Treasure>();

    Player alice, bob, carol;
    alice.loot = chest;  // count: 2
    bob.loot = chest;    // count: 3
    carol.loot = chest;  // count: 4

    // All players share the same treasure!
    alice.loot->gold -= 20;
    // bob.loot->gold is now 80 too!
}

👀 weak_ptr: The Careful Observer

What Is It?

weak_ptr is like a window to look at a toy, but you don’t own it. You can peek through, but the toy might disappear while you’re looking!

Why Do We Need It?

Problem: Circular References 🔄

class Child;

class Parent {
public:
    std::shared_ptr<Child> child;
};

class Child {
    // ❌ BAD: Creates a cycle!
    std::shared_ptr<Parent> parent;
};

graph LR
    P["Parent"] -->|shared_ptr| C["Child"]
    C -->|shared_ptr| P
    style P fill:#ff6b6b
    style C fill:#ff6b6b

Neither can be deleted! They point to each other forever. 😰

The Solution: weak_ptr

class Child {
    // ✅ GOOD: Breaks the cycle!
    std::weak_ptr<Parent> parent;
};

Using weak_ptr

#include <memory>

auto shared = std::make_shared<int>(42);
std::weak_ptr<int> weak = shared;

// To use it, you must "lock" it
if (auto locked = weak.lock()) {
    // locked is a shared_ptr
    // Safe to use!
    std::cout << *locked; // 42
}

// Check if it's still alive
if (!weak.expired()) {
    // Still exists!
}

Real Example: Observer Pattern

class Newsletter {
public:
    std::vector<std::weak_ptr<Reader>>
        subscribers;

    void notify() {
        for (auto& weak_reader : subscribers) {
            // Try to get the reader
            if (auto reader = weak_reader.lock()) {
                reader->receive("News!");
            }
            // If lock() returns nullptr,
            // reader was deleted - skip it!
        }
    }
};

🎨 Custom Deleters: Special Cleanup Rules

What Is It?

Sometimes toys need special cleanup instructions. Maybe a toy needs batteries removed, or a file needs closing.

A custom deleter tells the smart pointer: “When you’re done, do THIS specific cleanup.”

Basic Syntax

// Custom deleter function
void closeFile(FILE* f) {
    if (f) {
        std::cout << "Closing file!\n";
        fclose(f);
    }
}

// Use with unique_ptr
std::unique_ptr<FILE, decltype(&closeFile)>
    file(fopen("data.txt", "r"), closeFile);

// File auto-closes when 'file' is destroyed!

Lambda Deleter (Cleaner!)

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

shared_ptr Custom Deleter

// Easier syntax with shared_ptr!
std::shared_ptr<FILE> file(
    fopen("data.txt", "r"),
    [](FILE* f) {
        if (f) fclose(f);
    }
);

Real Example: Database Connection

class DBConnection {
public:
    void close() {
        // Cleanup logic
    }
};

auto createConnection() {
    auto conn = new DBConnection();

    // Custom deleter calls close()
    return std::shared_ptr<DBConnection>(
        conn,
        [](DBConnection* c) {
            c->close();
            delete c;
        }
    );
}

Array Deleter

// For arrays, use []
std::unique_ptr<int[]> arr(new int[10]);

// Or better: use make_unique
auto arr2 = std::make_unique<int[]>(10);

🗺️ The Complete Picture

graph TD
    SM["🎒 Smart Pointers"]

    SM --> UP["unique_ptr"]
    SM --> SP["shared_ptr"]
    SM --> WP["weak_ptr"]

    UP --> UP1["One owner only"]
    UP --> UP2["std::move to transfer"]
    UP --> UP3["make_unique to create"]

    SP --> SP1["Multiple owners"]
    SP --> SP2["Reference counting"]
    SP --> SP3["make_shared to create"]

    WP --> WP1["Non-owning observer"]
    WP --> WP2["Breaks cycles"]
    WP --> WP3["lock to access"]

🎯 Quick Decision Guide

Ask yourself:

1. Is there only ONE owner? → Use unique_ptr ✨

2. Do MULTIPLE things share ownership? → Use shared_ptr 🤝

3. Do you need to WATCH but not own? → Use weak_ptr 👀

4. Need CUSTOM cleanup? → Add a custom deleter 🧹

🏁 You Did It!

You now understand:

✅ unique_ptr - Exclusive ownership, one guardian ✅ make_unique - Safe factory for unique_ptr ✅ shared_ptr - Shared ownership with counting ✅ make_shared - Efficient factory for shared_ptr ✅ weak_ptr - Non-owning observer, breaks cycles ✅ Custom Deleters - Special cleanup instructions

Remember the story: Smart pointers are your cleanup robots. They never forget to put the toys away! 🤖🎒

💡 Golden Rules

1. Prefer make_unique and make_shared
2. Use unique_ptr by default
3. Use shared_ptr when you truly need sharing
4. Use weak_ptr to break cycles
5. Never use raw new/delete (unless you really must)

Now go write memory-safe C++ code! 🚀