The short answer is no, the OS does not lose control of the memory forever, and no, the application doesn’t necessarily crash right away.

Scenario A: While the Application is Running

When a memory leak happens, your application allocates memory (on the heap) but forgets to free it when it’s done.

• The OS Perspective: The OS doesn’t know you “leaked” it. As far as the OS is concerned, your application is still actively using that memory. The OS safely keeps that memory checked out exclusively for your app.
• Does it crash immediately? No. The application will keep running perfectly fine at first.
• What happens over time? If the leak keeps happening (like in a loop or a web server handling millions of requests), the application will keep demanding more and more memory.

Eventually, one of two things will cause a crash:

1. The application crashes itself: A std::bad_alloc exception is thrown by C++ because the system can no longer fulfill a new request. If unhandled, the app terminates.
2. The OS assassinates the application: If system-wide RAM gets dangerously low, operating systems like Linux invoke the OOM (Out Of Memory) Killer. The OS scans running processes, finds the one devouring all the RAM (your leaking app), and forcefully kills it to protect the rest of the machine from freezing.

Scenario B: The Moment the Application Closes

This is where the magic of modern virtual memory management comes in.

The moment your application terminates—whether it closes normally, crashes due to a bug, or is killed by the OS—the Operating System instantly and completely reclaims 100% of the leaked memory.

How the OS protects itself under the hood

Modern operating systems manage memory using an abstraction layer called Virtual Memory.

Your application never directly touches a physical slot on a RAM stick. Instead, the OS maintains a structure called a Page Table for each process. When your app requests memory, the OS maps virtual pages in your app to physical frames in actual RAM.

+---------------------+         +------------------+         +----------------------+
| Leaky C++ App       |  ====>  | OS Page Table    |  ====>  | Physical RAM         |
| (Thinks it owns RAM)|         | (The Real Map)   |         | (Actual Hardware)    |
+---------------------+         +------------------+         +----------------------+

When a process dies, the OS doesn’t go scouring your C++ code looking for missing delete keywords. It simply destroys that application’s Page Table.

Instantly, all the physical RAM frames that were mapped to that process are wiped and marked as “Available” for other programs.

💡 The Nuance: Embedded & Bare-Metal Exception

If you are working on Embedded Systems or Bare-Metal Firmware (where you write code directly on a microchip without a heavy OS like Linux, macOS or Windows), yes, a memory leak can steal memory forever (until a hard physical reset/reboot). Without an OS virtual memory layer to clean up behind you, a leak on a bare-metal heap permanently shrinks the available memory pool until the chip locks up.