Dynamic Memory

🏠 Memory Management: Your Computer’s Storage Room

Imagine your computer’s memory is like a big storage room in your house. When you want to keep toys (data), you need a place to put them. Today, we’ll learn how to be a smart room manager who knows exactly how to borrow space, return it, and never lose anything!

🎯 What We’ll Learn

1. new and delete - Borrowing and returning storage boxes
2. Memory Leaks - What happens when you forget to return boxes
3. RAII Principle - The magical self-cleaning helper
4. Ownership Semantics - Who’s responsible for which box?

📦 Part 1: The new and delete Operators

The Story of the Storage Room

Think of your computer like a toy library. When you want to play with a toy (use some memory), you go to the librarian and say “Can I borrow a box?”

• new = “Please give me a box to store my stuff!”
• delete = “I’m done! Here’s the box back!”

How It Works

When you use new, the computer finds an empty spot in the storage room and gives you the address (like a locker number). When you’re done, you use delete to give it back.

// Ask for ONE box to store a number
int* myNumber = new int;
*myNumber = 42;

// Done playing! Return the box
delete myNumber;

Borrowing Multiple Boxes (Arrays)

Sometimes you need MANY boxes at once—like borrowing a whole shelf!

// Ask for 5 boxes in a row
int* scores = new int[5];
scores[0] = 100;
scores[1] = 95;

// Return ALL 5 boxes together
delete[] scores;  // Note the []!

⚠️ Golden Rule

Never mix them up! It’s like returning a single book vs. a whole book set—different processes!

🚰 Part 2: Memory Leaks - The Forgotten Boxes

The Messy Kid Story

Imagine a kid who borrows toys from the library but never returns them. Day after day, they keep borrowing more and more. Eventually, the library runs out of toys for everyone else!

This is exactly what a memory leak is!

What Causes Memory Leaks?

void messyFunction() {
    int* toy = new int;  // Borrow a box
    *toy = 100;
    // Oops! Function ends but we
    // never said "delete toy"!
    // The box is lost forever! 😱
}

Every time this function runs, one more box gets lost!

Why Are Memory Leaks Bad?

graph TD
    A["Program Starts"] --> B["Borrows Memory"]
    B --> C["Forgets to Return"]
    C --> D["Borrows More Memory"]
    D --> E["Forgets Again"]
    E --> F["Computer Runs Out!"]
    F --> G["💥 Program Crashes"]

Common Leak Situations

1. Forgetting delete completely:

int* data = new int[1000];
// ... code runs ...
// No delete[]! Memory gone!

2. Early return before delete:

void risky() {
    int* ptr = new int;
    if (someError) {
        return;  // Leaked! Never
                 // reached delete
    }
    delete ptr;
}

3. Losing the address:

int* ptr = new int;
ptr = new int;  // Old address lost!
// First box can NEVER be returned!

🧹 Part 3: RAII - The Self-Cleaning Robot

The Magic Backpack Story

What if you had a magic backpack that automatically returns all borrowed toys when you’re done playing? You put toys in, play all day, and when you go home—poof!—everything gets returned automatically!

This is RAII: Resource Acquisition Is Initialization

(Big words, but simple idea!)

How RAII Works

In C++, when something goes “out of scope” (like leaving a room), its destructor runs automatically. We can use this to clean up!

class SmartBox {
    int* data;
public:
    // Constructor: borrow the box
    SmartBox() {
        data = new int;
    }

    // Destructor: auto-return!
    ~SmartBox() {
        delete data;  // Always runs!
    }
};

void safeFunction() {
    SmartBox box;  // Borrows memory
    // Do stuff...
}  // Box destroyed here =
   // memory auto-returned! ✨

The Beautiful Flow

graph TD
    A["Create Object"] --> B["Memory Allocated"]
    B --> C["Use the Object"]
    C --> D["Object Goes Out of Scope"]
    D --> E["Destructor Called Auto"]
    E --> F["Memory Freed! 🎉"]

Real-World RAII: Smart Pointers

C++ gives you ready-made magic backpacks called smart pointers!

#include <memory>

void modern() {
    // unique_ptr = single owner
    auto ptr =
        std::make_unique<int>(42);

    // No delete needed!
    // Auto-cleaned when function ends
}

👑 Part 4: Ownership Semantics

The “Whose Toy Is It?” Question

When you borrow a toy, someone needs to be responsible for returning it. In C++, we need to know: Who owns this memory?

Three Types of Ownership

1. Single Owner (Unique) Only ONE person can hold the toy. When they’re done, they return it.

std::unique_ptr<int> owner =
    std::make_unique<int>(100);
// Only 'owner' can delete this
// Can't copy, only MOVE!

2. Shared Ownership Multiple people share responsibility. The last one to leave returns it.

std::shared_ptr<int> p1 =
    std::make_shared<int>(100);
std::shared_ptr<int> p2 = p1;
// Both share ownership
// Deleted when BOTH are done

3. Observer (No Ownership) Just looking, not responsible for returning.

int* observer = owner.get();
// Can look at the data
// But NOT responsible for delete

Ownership Rules

Why Ownership Matters

graph TD
    A["Clear Ownership"] --> B["No Leaks"]
    A --> C["No Double-Delete"]
    A --> D["No Confusion"]
    E["Unclear Ownership"] --> F["Memory Leaks!"]
    E --> G["Crashes!"]
    E --> H["Bugs Everywhere!"]

🎯 Quick Summary

💪 You’ve Got This!

Memory management might seem scary, but it’s just like being a good library user:

1. Borrow what you need (new)
2. Return when done (delete)
3. Use helpers (RAII, smart pointers) to never forget
4. Know who’s responsible (ownership)

Modern C++ makes this easy with smart pointers. Use them, and you’ll rarely have memory problems!

Remember: The best memory manager is one who lets the computer handle cleanup automatically. That’s the power of RAII! 🚀