Memory Management in C++

What is Memory Management?

Memory management in C++ refers to the process of allocating, using, and releasing memory for variables and objects during the program's execution.

Types of Memory in C++

• Stack Memory: Automatically managed memory used for local variables.
• Heap Memory (Dynamic Memory): Manually managed memory used for dynamically allocated variables.

Memory Segments in C++

C++ programs use different memory segments:

1. Code Segment (.text): Contains executable instructions.
2. Data Segment:
   • Initialized Data Segment (.data): Contains global and static variables initialized by the user.
   • Uninitialized Data Segment (.bss): Contains uninitialized global and static variables.
3. Stack Segment: Manages local variables and function calls.
4. Heap Segment: Manages dynamically allocated memory (new/delete).

Stack Memory vs. Heap Memory

Stack Memory (Automatic Allocation)

Stack memory is used for local variables and function calls. It is automatically managed, meaning the memory is freed when the function exits.

Example:

#include <iostream>
using namespace std;

void stackExample() {
    int a = 10;   // Allocated on stack
    int b = 20;   // Allocated on stack
    cout << "a: " << a << ", b: " << b << endl;
} // Memory for a and b is automatically freed here

int main() {
    stackExample();
    return 0;
}

Output:

a: 10, b: 20

Explanation:

• Variables a and b are stored in stack memory.
• They are automatically destroyed when the function stackExample ends.

Heap Memory (Dynamic Memory Allocation)

Heap memory is manually managed using the new and delete operators.

How to Use Heap Memory:

• Use new to allocate memory dynamically.
• Use delete to free dynamically allocated memory.

Example:

#include <iostream>
using namespace std;

int main() {
    // Dynamically allocating an integer
    int *ptr = new int;    // Allocates memory on heap
    *ptr = 50;
    cout << "Value in heap: " << *ptr << endl;

    // Releasing dynamically allocated memory
    delete ptr;

    return 0;
}

Output:

Value in heap: 50

Explanation:

• Memory is allocated on the heap using new.
• Memory is released using delete.

Dynamic Memory for Arrays

Allocating Dynamic Arrays:

• Use new to allocate a dynamic array.
• Use delete[] to deallocate it.

Example:

#include <iostream>
using namespace std;

int main() {
    // Dynamically allocating an array
    int *arr = new int[5];

    // Initializing array
    for (int i = 0; i < 5; i++) {
        arr[i] = i + 1;
    }

    // Displaying array values
    cout << "Dynamic Array: ";
    for (int i = 0; i < 5; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    // Releasing dynamically allocated array
    delete[] arr;

    return 0;
}

Output:

Dynamic Array: 1 2 3 4 5 

Explanation:

• new int[5] creates a dynamic array of 5 integers.
• delete[] is used to free the dynamically allocated array.

Memory Management for Objects

Allocating Objects Dynamically:

You can also allocate objects of a class dynamically using new.

Example:

#include <iostream>
using namespace std;

// Class definition
class Student {
private:
    string name;
    int age;

public:
    Student(string n, int a) : name(n), age(a) {}
    
    void display() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

int main() {
    // Dynamically allocating an object
    Student *s1 = new Student("Alice", 21);
    s1->display();

    // Releasing the object memory
    delete s1;

    return 0;
}

Output:

Name: Alice, Age: 21

Memory Management

Memory Leak:

A memory leak occurs when memory is allocated but not properly deallocated.

Example of Memory Leak:

#include <iostream>
using namespace std;

void memoryLeak() {
    int *ptr = new int(100);  // Memory allocated
    // Memory not freed (memory leak)
}

int main() {
    memoryLeak();
    return 0;
}

Preventing Memory Leaks:

• Always use delete for every new.
• Use smart pointers (discussed later).

Dangling Pointer:

A dangling pointer is a pointer that points to a memory location that has already been freed.

Example:

#include <iostream>
using namespace std;

int main() {
    int *ptr = new int(10);
    delete ptr;  // Memory freed

    // Dangling pointer (accessing freed memory)
    cout << *ptr << endl; // Undefined behavior

    return 0;
}

Solution:

• Set pointer to nullptr after deleting.

delete ptr;
ptr = nullptr;

Smart Pointers

Smart pointers are a part of the C++ Standard Library (from C++11) that automatically manage memory, preventing memory leaks.

Types of Smart Pointers:

1. unique_ptr: Owns the memory and cannot be shared.
2. shared_ptr: Multiple pointers can share ownership.
3. weak_ptr: Does not own memory (used to avoid circular references).

Example (unique_ptr):

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

int main() {
    unique_ptr<int> ptr = make_unique<int>(42);
    cout << "Unique Pointer Value: " << *ptr << endl;
    return 0;
}

Output:

Unique Pointer Value: 42

Best Practices for Memory Management

1. Always use delete for every new.
2. For arrays, use delete[].
3. Set pointers to nullptr after deleting.
4. Prefer using smart pointers (unique_ptr, shared_ptr, weak_ptr) for automatic memory management.
5. Avoid accessing dangling pointers.

Summary

In this tutorial, you learned:

• The difference between stack and heap memory.
• How to dynamically allocate and deallocate memory using new and delete.
• How to manage memory for arrays and objects.
• Advanced concepts like memory leaks, dangling pointers, and smart pointers.