Why do you have to call delete for local variables of a function that are stored in the heap?

Question

Suppose that you have the following function:

 void doSomething(){
    int *data = new int[100];
 }

Why will this produce a memory leak? Since I can not access this variable outside the function, why doesn't the compiler call delete by itself every time a call to this function ends?

Answer 1

Why will this produce a memory leak?

Because you're responsible for deleting anything you create with new.

Why doesn't the compiler call delete by itself every time a call to this function ends?

Often, the compiler can't tell whether or not you still have a pointer to the allocated object. For example:

void doSomething(){
    int *data = new int[100];
    doSomethingElse(data);
}

Does doSomethingElse just use the pointer during the function call (in which case we still want to delete the array here)? Does it store a copy of the pointer for use later (in which case we don't want to delete it yet)? The compiler has no way of knowing; it's up to you to tell it. Rather than making a complicated, error-prone rule (like "you must delete it unless you can figure out that the compiler must know that there are no other references to it"), the rule is kept simple: you must delete it.

Luckily, we can do better than juggling a raw pointer and trying to delete it at the right time. The principle of RAII allows objects to take ownership of allocated resources, and automatically release them when their destructor is called as they go out of scope. Containers allow dynamic objects to be maintained within a single scope, and copied if needed; smart pointers allow ownership to be moved or shared between scopes. In this case, a simple container will give us a dynamic array:

void doSomething(){
    std::vector<int> data(100);
} // automatically deallocated

Of course, for a small fixed-size array like this, you might as well just make it automatic:

void doSomething(){
    int data[100];
} // all automatic variables are deallocated

Answer 2

The whole point of dynamic allocation like this is that you manually control the lifetime of the allocated object. It is needed and appropriate a lot less often than many people seem to think. In fact, I cannot think of a valid use of new[].

It is indeed a good idea to let the compiler handle the lifetime of objects. This is called RAII. In this particular case, you should use std::vector<int> data(100). Now the memory gets freed automatically as soon as data goes out of scope in any way.