Dynamic Memory Allocation in C++

# CHAPTER 12

Dynamic Memory Allocation #

1. Introduction #

2. Learning Objectives #

• Differentiate between Stack and Heap memory.

• Use the new operator to allocate memory.

• Use the delete operator to free memory.

• Prevent Memory Leaks.

• Allocate dynamic arrays.

3. Stack vs. Heap Memory #

• The Stack: Automatically managed. When you write int x = 5; in a function, it goes on the Stack. When the function ends, x is automatically destroyed. The Stack is small and fast.

• The Heap: Manually managed. It is a massive pool of RAM. Variables here stay alive until you explicitly destroy them. If you forget to destroy them, you cause a memory leak.

4. The new Operator #

#include <iostream>
using namespace std;

int main() {
    // Request memory for one integer on the Heap
    int* ptr = new int; 

    *ptr = 42; // Store 42 in that memory location
    cout << "Value: " << *ptr << endl;

    return 0;
} // WAIT! WE HAVE A PROBLEM HERE!

5. The delete Operator (Preventing Leaks) #

You must always use delete to free Heap memory.

int* ptr = new int(42); // Allocate and initialize to 42

cout << *ptr << endl;

delete ptr;    // 1. Give the memory back to the OS
ptr = nullptr; // 2. Safety: prevent Dangling Pointer bugs

6. Dynamic Arrays #

#include <iostream>
using namespace std;

int main() {
    int size;
    cout << "How many students? ";
    cin >> size;

    // Allocate an array dynamically based on user input!
    int* scores = new int[size]; 

    for(int i = 0; i < size; i++) {
        scores[i] = 100; // Initialize all to 100
    }

    // Freeing a dynamic array REQUIRES brackets []
    delete[] scores;
    scores = nullptr;

    return 0;
}

7. Memory-Level Visualization #

Stack                  Heap
+-----------+          +-------------------+
| ptr       | -------> | 42 (Integer)      |
| (Address) |          | (Address: 0x5A)   |
+-----------+          +-------------------+

After `delete ptr`: The Heap block is freed.
After `ptr = nullptr`: The Stack pointer no longer points to 0x5A.

8. Common Mistakes #

• Memory Leak: Using new without a matching delete. If this happens in a loop, your program will consume all your RAM and crash the computer.

• Dangling Pointer: Accessing a pointer *after* calling delete on it.

• Wrong Delete: Using delete ptr; instead of delete[] ptr; on a dynamic array. This only deletes the first element of the array!

• Double Free: Calling delete on the same pointer twice crashes the program.

9. Best Practices #

• Every time you type new, immediately type delete a few lines down so you don't forget.

• Modern C++ (C++11) strongly recommends Smart Pointers (std::unique_ptr) instead of raw new/delete because they delete themselves automatically (covered in Chapter 25).

10. Exercises #

1. 1. Write a program that asks the user for a number, dynamically allocates a float, assigns the number to it, prints it, and deletes it.

1. 2. Intentionally create a memory leak in a while(true) loop (WARNING: Open Task Manager to kill the process quickly!).

11. MCQ Quiz with Answers #

12. Interview Questions #

• Q: Explain the difference between Stack and Heap memory.

• Q: In C++, what is the difference between malloc() (from C) and new? (Answer: new calls the constructor of an object, malloc does not).

• Q: How do you track down a memory leak in a large C++ application? (Answer: Tools like Valgrind).

13. Summary #

14. Next Chapter Recommendation #