Cpp Dynamic Memory Allocation

C++ dynamic memory allocation

Created By: chatGPT

In C++, dynamic memory allocation allows you to manage memory more efficiently by allocating and deallocating memory at runtime. This is particularly useful for data structures such as linked lists, trees, or when the size of the array is not known at compile time. The primary operators for dynamic memory allocation are new and delete. Let's explore them with some code examples.

// Allocating an integer dynamically
int* ptr = new int;  // Allocate memory for one integer
*ptr = 5;           // Assign value

// Output the value
std::cout << "Value: " << *ptr << std::endl;

// Deallocate the memory
delete ptr;       // Release the allocated memory

You can also allocate arrays dynamically using new[]. It's essential to remember to use delete[] for releasing the memory allocated for arrays to prevent memory leaks.

// Allocating an array dynamically
int* arr = new int[5];  // Allocate memory for an array of 5 integers

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

// Output the values
for(int i = 0; i < 5; i++) {
    std::cout << "Value at index " << i << ": " << arr[i] << std::endl;
}

// Deallocate the array
delete[] arr;         // Release the allocated array memory

It's crucial to avoid memory leaks. Always make sure to delete any dynamically allocated memory when it's no longer needed. Failing to do so can lead to increased memory usage and might cause the program to crash or behave unexpectedly.

// Memory leak example
void memoryLeak() {
    int* leak = new int;  // This memory is not deallocated
}

// When you call the function, the allocated memory is lost
memoryLeak();  // Memory allocated for 'leak' is not freed

In modern C++, prefer using smart pointers like std::unique_ptr and std::shared_ptr to manage memory automatically and prevent leaks. Smart pointers take care of memory deallocation when they go out of scope, reducing the risk of memory leaks.

#include <iostream>
#include <memory>  // Include for smart pointers

void smartPointerExample() {
    std::unique_ptr<int> p1 = std::make_unique<int>(10);  // Automatically manages memory
    std::cout << "Value: " << *p1 << std::endl;
    // No need to manually delete
}

int main() {
    smartPointerExample();  // Memory is automatically freed
    return 0;
}