Is a processes memory reclaimed when it terminates?

Question

In an application of mine I basically allocate memory in C++ and enqueue it for deallocation in C#. This deallocation runs in the background and is non-deterministic, so in very rare cases it can theoretically happen that the application is exited before all the unmanaged memory is deallocated.

If that is the case, the behaviour is (roughly and very stripped down) the same as if my program was

int main()
{
   Foo* = new Foo();
   return 0;
}

my questions now are

• Is all the memory a program allocates, but not deallocates automatically reclaimed when the program exits or is it a memory leak that stays until I reboot?
• If it is automatically reclaimed, what mechanism is responsible for that?

EDIT: This is about Windows only, as some mentioned that this is OS-dependent.

EDIT 2: I am not talking about simply ignoring all memory leaks in my application, but about whether I need to make sure that all memory is properly deallocated right before the application exits.

EDIT 3: This is not about open file handles, destructors and side effects or anything, this is about memory that will be non-deterministically deallocated and very rare cases where the memory is not freed before termination.

Answer 1

If you care only about memory, you might not need to call delete because the operating system will destroy your entire virtual address space at process termination. Consider reading Operating Systems: Three Easy Pieces (freely downloadable) to understand more about OSes.

But you want to avoid memory leaks, so you'll better clean up properly. On some operating systems, you have tools like valgrind to help detect such leaks (so you don't want them to give spurious warnings).

Read also about RAII. In real life, the constructor (or other methods) of Foo (or indirect data used by it) could consume other resources (database connections, opened files, windows on your screen, daemon processes, remote connections to external services or web servers, robotic arms, etc...) and you want them to be disposed of properly.

Consider using smart pointers.

Liveness of a data structure is a whole program property. I recommend reading the GC handbook, at least to understand the concepts and terminology of garbage collection (which can be viewed as a way to manage resources, and not only raw memory).

^{(In practice, it depends a lot: if you are coding a million-lines of code program with hundreds of other programmers, you need to be more careful than if you are coding a tiny single-source file program alone; if you code a neural surgery robot it is not the same as a desktop application, etc.... so YMMV)}