This article is based on a thorough review of relevant authoritative literature and materials, forming a professional and reliable content. All data in the article is verifiable and traceable. Special note: The data and materials have been authorized. The content of this article does not involve any biased views and objectively describes the facts with a neutral attitude.

At the end of the article, there are the latest trending articles; feel free to check them out if you’re interested.

Continuously updated: Hands-on learning of CUDA programming

Modern C++ Efficient Programming Practical Manual: From Project Pain Points to the Essence of Modern C++

Hello everyone, today I continue to share valuable insights. Those who are familiar with me know that my real valuable content is usually in the middle and at the end. Please read patiently! Thank you.You can get the C++ interview emergency kit (which also includes classic C++ projects and books) at the end of the article.

Have you ever been overwhelmed by memory leaks or program crashes in C++ programming?

If so, I bet that eight out of ten times it’s due to improper use of <span>new[]</span> and <span>delete[]</span>. I can confidently tell you: yes, <span>new[]</span> and <span>delete[]</span> must be used in pairs! Otherwise, your program is like a programmer without clothes, potentially “running naked” and causing issues at any moment. Today, I will clarify this matter for you and throw in a few code examples that are easy to understand and can be used immediately after learning.

First, let’s clarify what new[] is and what delete[] is.

In C++, <span>new[]</span> is used to dynamically allocate an array, for example, <span>int* arr = new int[5]</span>, which allocates a contiguous block of memory sufficient to hold 5 <span>int</span>s. On the other hand, <span>delete[]</span> is its “recycling bin,” specifically used to clean up the memory allocated by <span>new[]</span>, for instance, <span>delete[] arr;</span>. These two are actually a pair of “old partners” designed to work together.

But here’s the problem: what happens if I don’t use them in pairs and instead use a regular <span>delete</span> to clean up the mess created by <span>new[]</span>? Let me give you a spoiler: the consequences are severe! Let me explain this slowly.

Why must they be paired? The “unwritten rules” of memory management

You might think that <span>new[]</span> and <span>delete[]</span> are merely for allocating and releasing memory, but this idea is somewhat “naive.” The reality is not that simple and direct.

When using <span>new[]</span>, the C++ compiler not only allocates memory for you but also secretly records the size of the array (for example, how many elements there are). Why? Because <span>delete[]</span> needs this information to function!

Especially when the array contains objects (for instance, when dealing with classes), <span>delete[]</span> needs to call the destructor for each object individually to clean them up thoroughly, and this operation can be quite cumbersome.

If you suddenly decide to use <span>delete</span> to release the memory allocated by <span>new[]</span>, the compiler gets confused: it cannot determine the size of the array and will treat the memory as a single object. The result? Either the program crashes or memory leaks occur; in short, nothing good will happen. It’s like hiring a cleaner who can only clean one room to clean an entire building; not only will the job be incomplete, but it may also make the building messier.

Example 1: The Consequences of Not Pairing—Memory “Naked Running”

Let’s look at an example to intuitively feel the consequences of not pairing:

The possible output is:

What’s going on? Three toys were thrown away, but only one was cleaned up! Because <span>delete</span> only recognizes the first element, the destructors for the other two toys were not called, and the memory is “naked running,” leading to a leak. Moreover, the C++ standard states that this operation is “undefined behavior,” meaning the program may crash at any time, and how it crashes is purely a matter of luck. Would you dare to write code like this?

Example 2: Correct Pairing—Memory Clean and Tidy

Now let’s look at the correct usage:

The output is:

This time it’s great! All three toys were cleaned up, and the memory is clean with no garbage left. <span>delete[]</span> knows there are three elements in the array and obediently calls the destructor for each <span>MyToy</span>.

Diving Deeper: Why Must It Be This Way?

You might ask: “Even for simple types like <span>int</span>, can’t it run just the same?” Hold on, I need to dig deeper.

Even if the array consists of simple types like <span>int</span>, using <span>delete</span> to release memory allocated by <span>new[]</span> may seem fine on the surface, but that’s merely “good luck.” The C++ standard still states: there exists undefined behavior. Different compilers and platforms may yield different results. For example:

Some compilers may not have issues, but others may crash directly, or the heap memory manager may malfunction. Why? Because within the memory block allocated by <span>new[]</span>, there may be “metadata” about the size of the array, which <span>delete[]</span> knows how to read, but <span>delete</span> does not recognize, and mishandling it can easily lead to problems.

My stance: don’t gamble on luck! C++ programming is not playing Russian roulette; using <span>new[]</span> and <span>delete[]</span> in pairs is like adding a “safety lock” to your code, ensuring it remains stable in any environment.

References

• Stroustrup B. (2013). The C++ Programming Language(4th ed). Addison-Wesley
• Meyers S. (2005). Effective C++: 55 Specific Ways to Improve Your Programs and Designs(3rd ed). Addison-Wesley

  Latest popular article recommendations:

  The Road to Recovery for C++ Developers: Most High-Paying Positions Are Hiring CUDA Talent, Are You Taking Action?

  From CUDA Novice to Expert: How I Optimized Complex Computational Tasks Using Thread Hierarchy

  Struggling with C++ File Operations in Project Development? This Article Is Enough!

  Tired of the Complexity of C++ Multilanguage Processing? This Article Will Help You Master Advanced Techniques Easily!

  Old Binary Operations Inefficient? C++23 New Features Teach You to Redefine Efficient I/O!

  Still Troubled by Time Handling in Old Projects? C++20/23 New Features Come to the Rescue!

#Memory Leak Culprit Every Programmer Must See: Mismatched new and delete##Advanced Must-Have