How to Safely Use new[] and delete[] in C++ Code

In C++, memory management is a critical aspect of programming, and improper handling can lead to issues like memory leaks or undefined behavior. When using new[] and delete[], it’s essential to understand their usage to ensure proper allocation and deallocation of memory. Below are some guidelines and best practices for safely using new[] and delete[] in C++.

1. Understanding new[] and delete[]

The new[] operator is used to allocate a dynamic array in heap memory, while delete[] is used to free the memory that was allocated by new[]. These operators are specifically designed for arrays and are different from new and delete, which are used for single object allocations.

• new[] allocates memory for an array of elements on the heap.

• delete[] frees the memory of an array allocated with new[].

Here’s a simple example of how they are used:

cpp
CopyEdit
int* arr = new int[10];  // Allocating memory for an array of 10 integers
// Use the array
delete[] arr;  // Deallocating the memory

2. Matching new[] with delete[]

One of the most common mistakes when using new[] and delete[] is mismatching the operators. If you use new[] to allocate memory, you must use delete[] to deallocate it. Using delete (for single objects) instead of delete[] can lead to undefined behavior, as the compiler expects different handling for arrays compared to single objects.

Incorrect usage:

cpp
CopyEdit
int* arr = new int[10];  // Allocating memory for an array
delete arr;  // Incorrect: should be delete[]

Correct usage:

cpp
CopyEdit
int* arr = new int[10];  // Allocating memory for an array
delete[] arr;  // Correct: using delete[] to free the array

3. Avoiding Memory Leaks

Memory leaks occur when dynamically allocated memory is not freed properly. It’s important to always use delete[] to release memory allocated by new[].

Example of a memory leak:

cpp
CopyEdit
int* arr = new int[5];
// Forgetting to call delete[] arr leads to a memory leak

Correct usage:

cpp
CopyEdit
int* arr = new int[5];
// Properly freeing memory
delete[] arr;

4. Pointer Validation Before Deletion

Before using delete[], ensure that the pointer is not nullptr. Although calling delete[] on a nullptr is safe in C++, it’s good practice to validate that the pointer is non-null to make the code more readable and prevent unnecessary operations.

cpp
CopyEdit
int* arr = new int[5];

// Other operations with arr

if (arr != nullptr) {
    delete[] arr;
    arr = nullptr;  // Set to nullptr to avoid dangling pointer
}

5. Avoid Double Deletion

Double deletion (attempting to delete the same pointer more than once) leads to undefined behavior. To prevent this, you can set the pointer to nullptr after deleting it. This helps to avoid accidentally deleting the same pointer again.

cpp
CopyEdit
int* arr = new int[5];
delete[] arr;
arr = nullptr;  // Setting pointer to nullptr after deleting

// Ensures no accidental second delete
if (arr != nullptr) {
    delete[] arr;  // Safe check
}

6. Avoid Using delete[] on Non-Dynamically Allocated Memory

You should never use delete[] on memory that wasn’t allocated using new[]. For example, if you allocate memory using a local array or a static array, trying to deallocate it using delete[] will result in undefined behavior.

Incorrect usage:

cpp
CopyEdit
int arr[10];  // Stack-allocated array
delete[] arr;  // Incorrect: should not use delete[] on stack arrays

Correct usage:

cpp
CopyEdit
int* arr = new int[10];  // Dynamically allocated array
delete[] arr;  // Correct: use delete[] for dynamic arrays

7. Avoid Using new[] for Simple Containers

In modern C++, the use of standard library containers such as std::vector and std::array is preferred for handling dynamic arrays. These containers manage memory automatically and offer additional safety and functionality. Using new[] and delete[] for arrays should only be done when you have specific performance or memory control requirements.

For example, instead of:

cpp
CopyEdit
int* arr = new int[100];  // Using new[] to create a dynamic array
delete[] arr;

You can use std::vector:

cpp
CopyEdit
std::vector<int> arr(100);  // Vector handles dynamic memory management automatically

8. Using Smart Pointers (Modern C++ Approach)

In modern C++, you can use smart pointers like std::unique_ptr or std::shared_ptr with custom deleters to manage memory automatically. These pointers automatically handle deallocation, preventing memory leaks or dangling pointers.

For example, using std::unique_ptr:

cpp
CopyEdit
#include <memory>

std::unique_ptr<int[]> arr = std::make_unique<int[]>(10);
// arr will automatically free memory when it goes out of scope

This approach eliminates the need for explicit delete[], as the memory will be automatically deallocated when the smart pointer goes out of scope.

9. Final Thoughts on Memory Management in C++

While new[] and delete[] are still part of C++, memory management in modern C++ focuses on safer, more convenient alternatives such as smart pointers and containers. These tools help prevent common mistakes like memory leaks and double deletion, which can be hard to debug in larger applications.

To summarize:

• Always match new[] with delete[].

• Use smart pointers (std::unique_ptr, std::shared_ptr) when possible.

• Prefer containers like std::vector over raw arrays in most cases.

• Check for nullptr before calling delete[], and avoid using delete[] on stack-allocated arrays.

• Set pointers to nullptr after deletion to avoid double deletion.

By following these practices, you can write safer, more reliable C++ code that avoids the common pitfalls of manual memory management.