Can a memory block allocated by using operator new/malloc persist beyond end of program execution? [duplicate]

Answer 1

Any good OS should clean up all resources when the process exits; the 'always free what you allocated' principle is good for two things:

1. If your program leaks memory but never exits (daemons, servers, ...) continuously leaking memory will waste RAM badly.

2. You should not defer freeing all memory until your program terminates (like Firefox does sometimes - noticed how much time it takes for it to exit?) - the point is to minimalize the time for which you have allocated memory; even if your program continues to run, you should immediately free up allocated RAM after you are finished with it.

Answer 2

For a historical note: the operating system used by old Amiga computers (“AmigaOS”) did not have full memory management as it is assumed now (except maybe for some later versions released when Amiga was no longer popular).

The CPU did not have a MMU (memory management unit), and as a consequence every process had access to all physical memory. Because of that when two processes wanted to share some information, they could just exchange pointers. This practice was even encouraged by the OS, which used this technique in its message-passing scheme.

However, this made it impossible to track which process owns which part of memory. Because of that the OS did not free memory of a finished process (or any other resource, for the fact). Freeing all allocated memory was therefore vital.

Answer 3

Short answer: No.

Long answer: No. C++ will never persist memory unless you do the work to make it do so. The reason to free memory is this:

If you don't free memory, but keep allocating it, you will run out at some point. Once you run out, almost anything can happen. On Linux, maybe the OOM killer is activated and your process is killed. Maybe the OS pages you completely to disk. Maybe you give a Windows box a blue screen if you use enough memory. It can almost be thought of as undefined behavior. Also, if you leak memory, it's just siting there, unused, unreleased, and no one can use it until your process terminates.

There's another reason too. When you release memory to the allocator, the allocator might keep it around, but just mark it as usable. That means that next time you need memory, it's already sitting there waiting for you. That means there are less calls into the kernel to ask for memory, increasing performance, as context switches are very inefficient.

EDIT: The C and C++ standards don't even give a guarantee that the memory will be cleaned up by the OS after termination. Many OSes and compilers may, but there is no guarantee. Despite this, all major desktop and mobile operation systems (with the exception of probably DOS and some very old embedded systems) do clean up a processes memory after it.

Answer 4

If you are very sure that you will never need to free the memory in the lifetime of the program, technically it may be alright to skip free/delete. Operating systems like Linux, Windows etc. will free up the allocated memory when the process ends. But in practice you can almost never make the assumption that the memory you allocate does not need to be freed within the lifetime of the process. Keeping code reusability, maintainability and extensibility in mind, it is a good practice to always free up everything that you allocate at the appropriate place.

Answer 5

This is an interesting question. My original take on your question was whether or not you could access memory after program completion, but after a second read I see you want to know why memory should be freed.

You free dynamically allocated memory, because if you don't the OS and other process will run out and you will have to reboot.

I thought you might want to access that memory after program completion, so my guess is that even if you wrote out the starting address and length of a dynamically allocated memory block -- to the console or a file -- that address might not be valid after the program completion.

That is because when your program is running you have a virtual page address, which you either might not be able to touch without kernel privileges after program completion. Or, there is another reason.

Answer 6

It certainly doesn't survive beyond program termination. The idea is to free memory when not needed anymore so that your program doesn't waste memory (it doesn't consume more then it really needs) or, even worse, doesn't run out of memory (depending on your allocation pattern)