Proper Memory Management for C++ Arrays of Pointers: An In-Depth Analysis of delete vs delete[]

Introduction

In C++ programming, memory management is a core and complex topic, especially when dealing with arrays of pointers. Proper use of delete and delete[] is crucial to avoid memory leaks and program crashes. This article, based on a common question, provides a detailed analysis of destructor methods for pointer arrays and offers best practice recommendations.

Problem Context

Consider the following code example:

class Foo
{
    Monster* monsters[6];

    Foo()
    {
        for (int i = 0; i < 6; i++)
        {
            monsters[i] = new Monster();
        }
    }

    virtual ~Foo();
}

Here, monsters is an array of 6 Monster* pointers, each dynamically allocated via new in the constructor. The issue is how to correctly implement the destructor to free these resources.

Analysis of Incorrect Approach

A common mistake is to use delete[] monsters;, as shown below:

Foo::~Foo()
{
    delete[] monsters;
}

This approach is incorrect because monsters itself is not a pointer to a dynamically allocated array but a static array (declared as a class member). In C++, static arrays are automatically freed when the class instance is destroyed, and manual delete[] is unnecessary. Incorrect use of delete[] can lead to undefined behavior, such as program crashes or memory corruption.

Correct Method Explanation

The correct destructor should delete each dynamically allocated object pointed to by the pointers, as follows:

Foo::~Foo()
{
    for (int i = 0; i < 6; i++)
    {
        delete monsters[i];
    }
}

Here, each monsters[i] is a pointer to a Monster object allocated via new, so delete must be used to free each object's memory. This adheres to C++ memory management rules: use delete for objects allocated with new, and delete[] for arrays allocated with new[].

In-Depth Understanding of Memory Allocation

To further clarify, consider a simpler example:

void example() {
    A* arr = new A[10];  // Dynamically allocate an array
    delete arr;          // Incorrect: only one destructor is called, may cause crash
    delete[] arr;        // Correct: calls all 10 destructors
}

In this example, arr points to a dynamically allocated array, so delete[] must be used to ensure all array elements are properly destroyed. Similarly, for arrays of pointers:

void example2() {
    A** arr = new A*[10];  // Dynamically allocate an array of pointers
    for (int i = 0; i < 10; i++) {
        arr[i] = new A(i); // Each pointer dynamically allocates an object
    }
    for (int i = 0; i < 10; i++) {
        delete arr[i];     // Delete each object
    }
    delete[] arr;          // Delete the array of pointers itself
}

Here, arr is a dynamically allocated array of pointers, so delete[] is needed to free the array memory, while the objects pointed to by arr[i] require delete. Using delete arr instead of delete[] arr would cause a memory leak of the pointer array.

Best Practices and Considerations

1. Match Allocation and Deallocation: Always pair new with delete, and new[] with delete[]. This is a fundamental principle of C++ memory management; violating it can lead to resource leaks or undefined behavior.

2. Handle Copy and Assignment: When managing dynamic memory in a class, define copy constructors and copy assignment operators to prevent double-deletion issues from shallow copies. For example, if the Foo class is copied, both instances' monsters arrays might point to the same memory, leading to deletion twice during destruction. This can be avoided by implementing deep copy or making copy operations private.

3. Use Smart Pointers: In modern C++, it is recommended to use smart pointers (e.g., std::unique_ptr or std::shared_ptr) to automate memory management and reduce errors from manual delete. For instance, changing the monsters array to std::unique_ptr<Monster>[6] can simplify destructor logic.

4. Testing and Debugging: Use memory detection tools (e.g., Valgrind) to check for memory leaks and ensure all dynamically allocated resources are properly freed.

Conclusion

In C++, proper memory management for arrays of pointers requires careful distinction between the array itself and its elements. For static or class member arrays, no manual deallocation is needed; for dynamically allocated objects, use delete; for dynamically allocated arrays, use delete[]. By following these rules and incorporating best practices, memory leaks and program errors can be effectively avoided, enhancing code robustness and maintainability.