Welcome to C++ Programming Tutorial

Dynamic Memory Allocation in C++

Dynamic Memory Allocation refers to the process of allocating memory during the runtime of a program. This is in contrast to static memory allocation, where memory is allocated at compile time. Dynamic memory allocation is crucial for creating programs that can handle varying amounts of data, especially when the size of data structures is not known in advance.

1. The new Operator

The new operator is used to allocate memory on the heap at runtime. It returns a pointer to the allocated memory. This allows for dynamic allocation of memory based on the needs of the program during execution.

#include <iostream>

int main() {
    // Allocating memory for an integer
    int* ptr = new int;

    // Assigning value to allocated memory
    *ptr = 10;
    std::cout << "Value: " << *ptr << std::endl;

    // Deallocate the memory
    delete ptr;

    return 0;
}
                    

In this example, new int allocates memory for an integer on the heap, and *ptr assigns the value 10 to it. The memory is then deallocated using delete.

2. Dynamic Memory Allocation with Arrays

You can also use the new operator to allocate memory for arrays. This is useful when you don't know the size of the array at compile time.

#include <iostream>

int main() {
    // Allocating memory for an array of 5 integers
    int* arr = new int[5];

    // Assigning values to the array
    for (int i = 0; i < 5; ++i) {
        arr[i] = i * 10;
    }

    // Printing values of the array
    for (int i = 0; i < 5; ++i) {
        std::cout << "arr[" << i << "] = " << arr[i] << std::endl;
    }

    // Deallocate the memory
    delete[] arr;

    return 0;
}
                    

Here, new int[5] allocates memory for an array of 5 integers. The memory is deallocated using delete[], which is necessary for arrays.

3. Dynamic Memory Deallocation

Memory allocated with the new operator must be deallocated using the delete operator to avoid memory leaks. For arrays allocated with new[], use delete[].

#include <iostream>

int main() {
    int* singlePtr = new int;
    int* arrayPtr = new int[10];

    // Deallocate single memory block
    delete singlePtr;

    // Deallocate array memory
    delete[] arrayPtr;

    return 0;
}
                    

In this example, delete singlePtr deallocates memory for a single integer, while delete[] arrayPtr deallocates memory for an array of integers.

Important Points:

• Always pair new with delete and new[] with delete[] to avoid undefined behavior.
• Failing to deallocate memory can lead to memory leaks, which can degrade performance and cause the application to crash.