Dynamic Memory Allocation in C++

Dynamic memory allocation is an essential concept in C++ that allows you to allocate and deallocate memory at runtime. It gives you the flexibility to create and manipulate objects dynamically, enabling you to efficiently manage memory resources in your programs. In this lesson, we'll explore how to perform dynamic memory allocation in C++ using the new and delete operators, as well as the memory management functions provided by the C++ Standard Library.

Allocation and Deallocation with new and delete

In C++, you can allocate memory dynamically using the new operator. This allows you to create objects on the heap, which have a longer lifespan than objects created on the stack. Once you're done with the dynamically allocated memory, you should deallocate it using the delete operator to release the memory back to the system.

int* ptr = new int; // Allocates memory for an integer on the heap
*ptr = 10; // Assigns a value to the dynamically allocated integer
delete ptr; // Deallocates the memory

Array Allocation and Deallocation

You can also allocate arrays dynamically in C++ using the new operator. Remember to use the delete[] operator to deallocate dynamically allocated arrays.

int* arr = new int[5]; // Allocates an array of integers on the heap
for (int i = 0; i < 5; i++) {
    arr[i] = i + 1; // Assigns values to the dynamically allocated array
}
delete[] arr; // Deallocates the memory

Smart Pointers for Automatic Memory Management

C++ also provides smart pointers, such as unique_ptr and shared_ptr , which help automate memory management. Smart pointers handle deallocation automatically based on their scope or reference count, eliminating the need for explicit delete statements and reducing the chances of memory leaks.

#include <memory>

std::unique_ptr<int> ptr = std::make_unique<int>(10); // Allocates memory and assigns value
// Memory will be deallocated automatically when the unique_ptr goes out of scope

Conclusion

Dynamic memory allocation in C++ is a powerful feature that allows you to manage memory resources at runtime. By using the new and delete operators, as well as smart pointers, you can create and release memory dynamically, enabling you to efficiently work with objects of varying sizes and lifetimes. However, be cautious when working with dynamic memory to prevent memory leaks and undefined behavior. Understanding and properly managing dynamic memory allocation will help you write robust and efficient C++ programs.