Introduction to C++ | Memory Management

C++ Memory Management

Memory management in C++ refers to the process of managing the allocation, use, and release of memory in a program. It is one of the key features of C++ because it allows developers fine-grained control over how memory is handled, unlike higher-level languages that use automatic memory management (e.g., garbage collection). Proper memory management is essential for creating efficient and error-free programs, especially in resource-constrained environments.

Types of Memory in C++

In C++, memory is divided into two main categories:

• Stack Memory: This memory is used for storing local variables, function call data, and function parameters. It is automatically managed and is typically faster but has limited size.
• Heap Memory: This memory is used for dynamic memory allocation, where memory is manually allocated and deallocated using new and delete operators. It is more flexible but requires careful management to avoid memory leaks and fragmentation.

Allocating Memory Dynamically (Heap Memory)

C++ allows dynamic memory allocation using the new operator. The new operator allocates memory on the heap, and the programmer is responsible for freeing that memory using the delete operator.

Syntax for allocating memory dynamically using new:

        pointer = new dataType; // Allocates memory for one element
        pointer = new dataType[size]; // Allocates memory for an array
                    

Example of Using new and delete

The following example demonstrates the use of new to allocate memory and delete to release the allocated memory:

        #include <iostream>
        using namespace std;
        
        int main() {
            // Dynamically allocate memory for an integer
            int* ptr = new int;
        
            // Assign a value to the allocated memory
            *ptr = 10;
            cout << "Value: " << *ptr << endl;
        
            // Free the allocated memory
            delete ptr;
        
            // Dynamically allocate memory for an array of integers
            int* arr = new int[5];
        
            // Assign values to the array
            for (int i = 0; i < 5; i++) {
                arr[i] = i * 2;
            }
        
            // Print array values
            for (int i = 0; i < 5; i++) {
                cout << "arr[" << i << "] = " << arr[i] << endl;
            }
        
            // Free the array memory
            delete[] arr;
        
            return 0;
        }
                    

Output

Memory Leaks and How to Avoid Them

A memory leak occurs when memory is allocated but not properly deallocated. This can lead to wasted memory and potential program crashes over time. To avoid memory leaks:

• Always use delete or delete[] to free dynamically allocated memory.
• Consider using smart pointers such as std::unique_ptr and std::shared_ptr for automatic memory management.
• Use memory profiling tools to detect and resolve memory leaks in your program.

Smart Pointers in C++

Smart pointers are wrappers around raw pointers that help manage memory automatically. They ensure that the memory is freed when the pointer goes out of scope, reducing the risk of memory leaks.

• std::unique_ptr: A smart pointer that owns and manages a dynamically allocated object. It automatically deletes the object when it goes out of scope.
• std::shared_ptr: A smart pointer that allows multiple pointers to share ownership of the same object. The object is deleted when the last shared_ptr pointing to it is destroyed.
• std::weak_ptr: A smart pointer that allows observing a shared_ptr without affecting its reference count.

Example of Using Smart Pointers

Here’s an example demonstrating the use of std::unique_ptr to manage dynamically allocated memory:

        #include <iostream>
        #include <memory>
        using namespace std;
        
        int main() {
            // Create a unique_ptr to manage memory
            unique_ptr ptr = make_unique();
        
            *ptr = 20;
            cout << "Value: " << *ptr << endl;
        
            // No need to manually delete; memory will be freed when ptr goes out of scope
            return 0;
        }
                    

Output

Pro Tip: