Dynamic Memory Allocation

In C++, dynamic memory allocation is the process of allocating memory at runtime using the new operator. The new operator returns a pointer to the allocated memory.

Example of dynamic memory allocation:

1// Allocate an integer
2int* ptr = new int;
3
4// Allocate an array of 5 integers
5int* arr = new int[5];

Dynamic memory allocation is useful in several scenarios:

1. When the size of the data is not known at compile time (e.g., user input).
2. When you need to allocate large amounts of memory that would exceed the stack size.
3. When you need data to persist beyond the scope of a function.

After dynamically allocating memory, it's important to deallocate it using the delete operator to avoid memory leaks.

Example of deallocating dynamically allocated memory:

1// Deallocate the single integer
2delete ptr;
3
4// Deallocate the array of integers
5delete[] arr;

It's also recommended to use smart pointers (e.g., unique_ptr, shared_ptr) that automatically handle memory deallocation.

Example of using a smart pointer for dynamic memory:

1#include <memory>
2
3// Allocate an integer
4auto ptr = std::make_unique<int>(5);
5
6// Allocate an array of 5 integers
7auto arr = std::make_unique<int[]>(5);

By understanding dynamic memory allocation, you can create more flexible and efficient C++ programs that can handle varying amounts of data.