C++ Memory Management

Memory management is a critical aspect of programming, especially in a statically-typed language like C++. In C++, memory is managed using dynamic memory allocation and deallocation through the use of pointers and the new and delete operators. Understanding the basics of C++ memory management is essential for writing efficient, robust, and scalable code.

Dynamic Memory Allocation

Dynamic memory allocation is the process of allocating memory dynamically at runtime, as opposed to statically at compile time. The new and delete operators are used in C++ for dynamic memory allocation and deallocation, respectively. The new operator is used to allocate memory dynamically at runtime, and returns a pointer to the block of memory that has been allocated. The delete operator is used to deallocate memory that was previously allocated with new.

For example, to dynamically allocate memory for an integer, you would use the following code:

int *integerPointer = new int;

To deallocate the memory, you would use the following code:

delete integerPointer;

It's important to deallocate memory that was dynamically allocated with new, as failing to do so can lead to memory leaks, which can have serious consequences for the performance and stability of your program.

int main() {
    int *integerPointer = new int;
    *integerPointer = 10;
    cout << *integerPointer << endl;
    delete integerPointer;
    return 0;
}

Output

In this example, we allocate memory for an integer using the new operator and store the address of the memory block in the pointer integerPointer. We then assign the value 10 to the memory block, and use the cout stream operator to print the value stored at the address pointed to by integerPointer. Finally, we use the delete operator to deallocate the memory that was previously allocated with new, freeing it for reuse.

Array Allocation

Dynamic memory allocation can also be used to allocate memory for arrays. When using new to allocate memory for arrays, the delete[] operator should be used instead of delete. Using delete[] instead of delete when deallocating arrays is important, as it informs the C++ runtime that the memory block being deallocated is an array, rather than a single object. For example:

int main() {
    int arraySize = 5;
    int *integerArrayPointer = new int[arraySize];
    for (int index = 0; index < arraySize; index++) {
        integerArrayPointer[index] = index;
    }
    for (int index = 0; index < arraySize; index++) {
        cout << integerArrayPointer[index] << " ";
    }
    cout << endl;
    delete[] integerArrayPointer;
    return 0;
}

Output

0 1 2 3 4

In this example, we allocate memory for an array of 5 integers using the new operator and store the address of the memory block in the pointer integerArrayPointer. We then use a for loop to assign values to the array, and another for loop to print the values stored in the array. Finally, we use the delete[] operator to deallocate the memory that was previously allocated with new, freeing it for reuse.