Why do I need to delete[]?

Question

Lets say I have a function like this:

int main()
{
    char* str = new char[10];

    for(int i=0;i<5;i++)
    {
        //Do stuff with str
    }

    d         


        

Answer 1

You got a lot of professional experience answers. Here I'm telling a naive but an answer I considered as the fact.

• Summary

  3. Does it have deeper consequences?

  A: Will answer in some detail.

  2. Is it just good practice?

  A: It is considered a good practice. Release resources/memory you've retrieved when you're sure about it no longer used.

  1. Why would I need to delete str if I am going to end the program anyways?
     I wouldn't care if that memory goes to a land full of unicorns if I am just going to exit, right?

  A: You need or need not, in fact, you tell why. There're some explanation follows.

  I think it depends. Here are some assumed questions; the term program may mean either an application or a function.

  Q: Does it depend on what the program does?

  A: If universe destroyed was acceptable, then no. However, the program might not work correctly as expected, and even be a program that doesn't complete what it supposed to. You might want to seriously think about why you build a program like this?

  Q: Does it depend on how the program is complicated?

  A: No. See Explanation.

  Q: Does it depend on what the stability of the program is expected?

  A: Closely.

  And I consider it depends on

  1. What's the universe of the program?
  2. How's the expectation of the program that it done its work?

  3. How much does the program care about others, and the universe where it is?

     About the term universe, see Explanation.

  For summary, it depends on what do you care about.

---

• Explanation

  Important: If we define the term program as a function, then its universe is application. There are many details omitted; as an idea for understanding, it's long enough, though.

  We may ever seen this kind of diagram which illustrates the relationship between application software and system software.

  

  But for being aware the scope of which one covers, I'd suggest a reversed layout. Since we are talking about software only, the hardware layer is omitted in following diagram.

  

  With this diagram, we realize that the OS covers the biggest scope, which is current the universe, sometimes we say the environment. You may imagine that the whole achitecture consists of a lot of disks like the diagram, to be either a cylinder or torus(a ball is fine but difficult to imagine). Here I should mention that the outmost of OS is in fact a unibody, the runtime may be either single or multiple by different implemention.

  It's important that the runtime is responsible to both OS and applications, but the latter is more critical. Runtime is the universe of applications, if it's destroyed all applications run under it are gone.

  Unlike human on the Earth, we live here, but we don't consist of Earth; we will still live in other suitable environment if the time when the Earth are destroying and we weren't there.

  However, we can no longer exist when the universe is destroyed, because we are not only live in the universe, but also consist of the universe.

  As mentioned above, the runtime is also responsible to the OS. The left circle in the following diagram is what it may looks like.

  

  This is mostly like a C program in the OS. When the relationship between an application and OS match this, is just the same situation as runtime in the OS above. In this diagram, the OS is the universe of applications. The reason of the applications here should be responsible to the OS, is that OS might not virtualize the code of them, or allowed to be crashed. If OS are always prevent they to do so, then it's self-responsible, no matter what applications do. But think about the drivers, it's one of the scenarios that OS must allowed to be crashed, since this kind of applications are treated as part of OS.

  Finally, let's see the right circle in the diagram above. In this case, the application itself be the universe. Sometimes, we call this kind of application operating system. If an OS never allowed custom code to be loaded and run, then it does all the things itself. Even it allowed, after itself is terminated, the memory goes nowhere but hardware. All the deallocation that may be necessary, is before it was terminated.

  So, how much does your program care about the others? How much does it care about its universe? And how's the expectation of the program that it done its work? It depends on what do you care about.