Dynamic Memory Allocation Explained

Dynamic memory allocation in C++ allows you to allocate memory at runtime, providing flexibility in managing memory resources. This section will cover the key concepts related to dynamic memory allocation in C++.

Key Concepts

1. new Operator

The new operator is used to allocate memory dynamically for a single object or an array of objects. It returns a pointer to the allocated memory.

Example:

#include <iostream>
using namespace std;

int main() {
    int* ptr = new int;  // Allocate memory for a single integer
    *ptr = 10;  // Assign a value to the allocated memory
    cout << "Value: " << *ptr << endl;
    delete ptr;  // Deallocate the memory
    return 0;
}
    

2. delete Operator

The delete operator is used to deallocate memory that was previously allocated using the new operator. It frees the memory and returns it to the system.

Example:

#include <iostream>
using namespace std;

int main() {
    int* ptr = new int(20);  // Allocate and initialize memory for an integer
    cout << "Value: " << *ptr << endl;
    delete ptr;  // Deallocate the memory
    return 0;
}
    

3. new[] Operator

The new[] operator is used to allocate memory dynamically for an array of objects. It returns a pointer to the first element of the allocated array.

Example:

#include <iostream>
using namespace std;

int main() {
    int* arr = new int[5];  // Allocate memory for an array of 5 integers
    for (int i = 0; i < 5; i++) {
        arr[i] = i * 10;
    }
    for (int i = 0; i < 5; i++) {
        cout << "Element " << i << ": " << arr[i] << endl;
    }
    delete[] arr;  // Deallocate the memory
    return 0;
}
    

4. delete[] Operator

The delete[] operator is used to deallocate memory that was previously allocated using the new[] operator. It frees the memory allocated for the entire array.

Example:

#include <iostream>
using namespace std;

int main() {
    int* arr = new int[3]{10, 20, 30};  // Allocate and initialize memory for an array of 3 integers
    for (int i = 0; i < 3; i++) {
        cout << "Element " << i << ": " << arr[i] << endl;
    }
    delete[] arr;  // Deallocate the memory
    return 0;
}
    

5. Memory Leaks

Memory leaks occur when dynamically allocated memory is not properly deallocated, leading to a loss of memory resources. It is crucial to use the delete and delete[] operators to avoid memory leaks.

Example:

#include <iostream>
using namespace std;

int main() {
    int* ptr = new int(40);  // Allocate memory for an integer
    cout << "Value: " << *ptr << endl;
    // delete ptr;  // Uncomment this line to avoid memory leak
    return 0;
}
    

Examples and Analogies

Example: Dynamic Array Allocation

#include <iostream>
using namespace std;

int main() {
    int size;
    cout << "Enter the size of the array: ";
    cin >> size;
    
    int* arr = new int[size];  // Allocate memory for an array of given size
    for (int i = 0; i < size; i++) {
        arr[i] = i * 5;
    }
    for (int i = 0; i < size; i++) {
        cout << "Element " << i << ": " << arr[i] << endl;
    }
    delete[] arr;  // Deallocate the memory
    return 0;
}
    

Analogy: Dynamic Memory as a Rental Car

Think of dynamic memory allocation as renting a car. When you need a car, you rent it (allocate memory) and use it for your needs. Once you are done using it, you return it (deallocate memory) so that it can be used by someone else. If you forget to return the car, it remains unavailable for others (memory leak).