Dynamic Memory Allocation (new, delete)

Dynamic memory allocation is a powerful feature in C++ that allows you to allocate memory during the runtime of your program. This is in contrast to static memory allocation, where memory is allocated at compile time. The new and delete operators are fundamental to dynamic memory allocation in C++, enabling you to create and destroy objects and arrays as needed, providing flexibility and efficiency in resource management. However, it is crucial to manage dynamic memory carefully to avoid memory leaks and other related issues.

What is Dynamic Memory Allocation (new, delete)

Dynamic memory allocation provides a mechanism to request memory from the operating system’s heap during program execution. This is particularly useful when the size of the memory required is not known at compile time or when you need to create objects or arrays that outlive the scope in which they were created.

The new operator allocates a block of memory of the specified size and returns a pointer to the beginning of that block. The delete operator deallocates a block of memory that was previously allocated using new, returning it to the heap for reuse.

In-depth Explanation:

Heap vs. Stack: Dynamic memory is allocated from the heap, a region of memory managed by the operating system. The stack, on the other hand, is used for automatic variables and function call information. The stack is typically smaller and faster than the heap, but its size is limited.
Memory Leaks: A memory leak occurs when memory is allocated using new but never deallocated using delete. This can lead to a gradual depletion of available memory, eventually causing the program to crash or become unstable.
Double Deletion: Attempting to delete the same memory address twice leads to undefined behavior, often resulting in a crash or corruption of the heap.
Dangling Pointers: A dangling pointer is a pointer that points to a memory location that has already been deallocated. Accessing a dangling pointer results in undefined behavior.
Performance Considerations: Dynamic memory allocation and deallocation can be relatively slow compared to stack allocation due to the overhead of managing the heap. Frequent allocation and deallocation can fragment the heap, leading to further performance degradation.
Exception Safety: When using new in a function, consider what happens if an exception is thrown after the memory is allocated but before it is deallocated. Use RAII (Resource Acquisition Is Initialization) to ensure that the memory is properly deallocated even in the event of an exception.

Syntax and Usage

new Operator:

Allocating a single object:


int* ptr = new int; // Allocates memory for a single integer

Allocating an array:


int* arr = new int[10]; // Allocates memory for an array of 10 integers

Allocating and initializing an object:


int* ptr = new int(42); // Allocates memory for an integer and initializes it to 42

Allocating an object of a class type:


class MyClass {
public:
    MyClass(int value) : value_(value) {}
private:
    int value_;
};
 
MyClass* obj = new MyClass(10); // Allocates memory for a MyClass object and calls the constructor

delete Operator:

Deallocating a single object:


delete ptr; // Deallocates the memory pointed to by ptr
ptr = nullptr; // Set the pointer to null to avoid dangling pointer issues

Deallocating an array:


delete[] arr; // Deallocates the memory pointed to by arr (note the square brackets)
arr = nullptr; // Set the pointer to null to avoid dangling pointer issues

Important Notes:

Always use delete[] to deallocate memory allocated with new[]. Using delete instead of delete[] for an array can lead to memory corruption.
Always set pointers to nullptr after deallocating the memory they point to. This helps prevent dangling pointer issues.
Be mindful of exception safety when using new. Use RAII (smart pointers) to ensure proper memory management even in the presence of exceptions.

Basic Example


#include <iostream>
 
int main() {
    // Allocate memory for an integer
    int* myInt = new int;
 
    // Check if allocation was successful
    if (myInt == nullptr) {
        std::cerr << "Memory allocation failed!" << std::endl;
        return 1;
    }
 
    // Assign a value to the allocated memory
    *myInt = 100;
 
    // Print the value
    std::cout << "Value: " << *myInt << std::endl;
 
    // Deallocate the memory
    delete myInt;
    myInt = nullptr; // Set to null to avoid dangling pointer
 
    return 0;
}

Explanation:

The code allocates memory for a single integer using new int.
It checks if the allocation was successful by verifying if the returned pointer is nullptr. This is crucial to handle cases where the system might not have enough memory available.
It assigns the value 100 to the allocated memory using the dereference operator *.
It prints the value stored in the allocated memory.
Finally, it deallocates the memory using delete myInt and sets myInt to nullptr to prevent it from becoming a dangling pointer.

Advanced Example


#include <iostream>
#include <string>
#include <stdexcept>
 
class DynamicStringArray {
private:
    std::string* data;
    size_t size;
    size_t capacity;
 
public:
    DynamicStringArray(size_t initialCapacity = 10) : size(0), capacity(initialCapacity) {
        data = new std::string[capacity];
        if (data == nullptr) {
            throw std::bad_alloc(); // Handle allocation failure
        }
    }
 
    ~DynamicStringArray() {
        delete[] data;
    }
 
    DynamicStringArray(const DynamicStringArray& other) : size(other.size), capacity(other.capacity) {
        data = new std::string[capacity];
        if (data == nullptr) {
            throw std::bad_alloc();
        }
        for (size_t i = 0; i < size; ++i) {
            data[i] = other.data[i];
        }
    }
 
    DynamicStringArray& operator=(const DynamicStringArray& other) {
        if (this != &other) {
            std::string* newData = new std::string[other.capacity];
             if (newData == nullptr) {
                throw std::bad_alloc();
            }
 
            for (size_t i = 0; i < other.size; ++i) {
                newData[i] = other.data[i];
            }
 
            delete[] data;
            data = newData;
            size = other.size;
            capacity = other.capacity;
        }
        return *this;
    }
 
    void add(const std::string& str) {
        if (size == capacity) {
            // Resize the array
            size_t newCapacity = capacity * 2;
            std::string* newData = new std::string[newCapacity];
            if (newData == nullptr) {
                throw std::bad_alloc();
            }
 
            for (size_t i = 0; i < size; ++i) {
                newData[i] = data[i];
            }
 
            delete[] data;
            data = newData;
            capacity = newCapacity;
        }
        data[size++] = str;
    }
 
    std::string get(size_t index) const {
        if (index >= size) {
            throw std::out_of_range("Index out of bounds");
        }
        return data[index];
    }
 
    size_t getSize() const {
        return size;
    }
};
 
int main() {
    try {
        DynamicStringArray myArray;
        myArray.add("Hello");
        myArray.add("World");
        myArray.add("!");
 
        for (size_t i = 0; i < myArray.getSize(); ++i) {
            std::cout << myArray.get(i) << " ";
        }
        std::cout << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    }
 
    return 0;
}

This example demonstrates a DynamicStringArray class, which dynamically allocates memory to store strings. It includes:

Constructor: Allocates memory for the array. Handles potential allocation failures by throwing std::bad_alloc.
Destructor: Deallocates the memory.
Copy Constructor: Creates a deep copy of the array. Handles potential allocation failures.
Assignment Operator: Implements the copy-and-swap idiom to safely handle self-assignment and exceptions. Creates a new array, copies the data, and then deletes the old array.
add() Method: Adds a string to the array. If the array is full, it reallocates memory to double the capacity. Handles potential allocation failures.
get() Method: Retrieves a string from the array. Performs bounds checking and throws std::out_of_range if the index is invalid.

This example showcases the importance of the Rule of Five (or Zero) when dealing with dynamic memory allocation. It also demonstrates exception safety by handling potential allocation failures and ensuring that resources are properly released even in the presence of exceptions.

Common Use Cases

Dynamic Arrays: Creating arrays whose size is not known at compile time.
Data Structures: Implementing dynamic data structures like linked lists, trees, and graphs.
Object Creation: Creating objects on the heap with lifetimes that extend beyond the scope in which they were created.

Best Practices

RAII (Resource Acquisition Is Initialization): Use smart pointers (e.g., std::unique_ptr, std::shared_ptr) to manage dynamically allocated memory automatically. This helps prevent memory leaks and simplifies resource management.
Avoid Raw Pointers: Minimize the use of raw pointers for ownership. Smart pointers are generally a better choice.
Check for Allocation Failures: Always check if new returns nullptr (or use the throwing version of new) and handle the failure appropriately.
Initialize Pointers After Deletion: Set pointers to nullptr after deleting the memory they point to, to prevent dangling pointer issues.
Use delete[] for Arrays: Remember to use delete[] when deallocating memory allocated with new[].
Prefer Standard Containers: When possible, use standard containers like std::vector, std::string, and std::list, which handle memory management automatically.

Common Pitfalls

Memory Leaks: Forgetting to delete memory allocated with new.
Double Deletion: Deleting the same memory address twice.
Dangling Pointers: Accessing memory that has already been deallocated.
Using delete instead of delete[]: Incorrectly deallocating arrays.
Ignoring Allocation Failures: Not checking if new returns nullptr.

Key Takeaways

Dynamic memory allocation allows you to allocate memory during runtime using new and delete.
Proper memory management is crucial to prevent memory leaks, double deletions, and dangling pointers.
Use RAII (smart pointers) to simplify memory management and ensure exception safety.
Prefer standard containers when possible, as they handle memory management automatically.