C potential memory leak caused by abnormally terminating program - c

Question

Windows and Linux.
When I allocate memory in my C program, good coding wants me to free the memory before the end of my program.
Assume the following:
int main (int argc, char *argv[]) {
char *f_name;
FILE *i_file;
f_name = malloc(some_amount);
// put something in f_name */
i_file = fopen(f_name, "r");
if (i_file == NULL) {
perror("Error opening file.");
exit(EXIT_FAILURE);
}
free(f_name);
return EXIT_SUCCESS;
}
If the program terminates before I call "free", will the OS recover any un-freed memory when the program exits? Or will I just nibble away from my 3Gb or so available memory until a system restart?
Thanks, Mark.

Answer 1

You don't have to worry about it on popular OSes like Windows and Linux.
Virtual memory ceases to exist when the process terminates. So it's not possible for it to leak after a process terminates.
Physical memory always belongs to the OS to allocate as it pleases, whether or not your process is still running. (Unless you lock your allocations, in which case it ceases to be locked when the corresponding virtual memory mapping is destroyed which happens on process termination anyway.)
There are a few resources that are not cleaned up (like some types of shared memory) but that's pretty exotic.
When you call malloc, typically just backing store (essentially RAM+swap) is reserved and a virtual memory mapping (which is essentially free) is created. When you first write to that virtual memory mapping, physical pages of memory (RAM) are mapped into it to "back" it. That RAM always belongs to the OS to use as it pleases and the OS will re-use the RAM for other purposes if it deems that wise.
When a process terminates, its address space ceases to exist. That means any virtual memory mappings or reservations go away. Unshared physical pages will have their use count drop to zero when the virtual memory mapping goes away, rendering those pages of physical memory free.
It's worth understanding this in detail because you can easily draw the wrong conclusions about edge cases if you don't understand what's going on under the hood. Also, this will give you a framework to plug concepts such as file mappings, memory overcommit, and shared memory into.

Answer 2

The memory is reclaimed by the OS.
Some programs (like webservers) are never meant to exit, they just keep running and serving requests. Memory they allocate technically doesn't need to be returned.

Answer 3

In your example, taking this branch would indeed cause memory to leak:
f_name = malloc(some_amount);
// put something in f_name */
i_file = fopen(f_name, "r");
if (i_file == NULL) {
perror("Error opening file.");
exit(EXIT_FAILURE); // <--- f_name leaks here!
}
It's just a once-off leak which doesn't recur frequently throughout the life of the program and common OSes will clean up leaked memory upon termination. It'd be unlikely to be a problem impacting upon system-wide performance, however it would be a diagnostic highlighted by instruments such as Valgrind and so it'd be wise for debugging purposes to free(f_name); before you exit(EXIT_FAILURE); in that instance.
That termination isn't considered abnormal, as it's caused by a call to exit. Nonetheless, an abnormal termination caused by a call to abort or a signal being raised is likely to compound on top of this leak.
will the OS recover any un-freed memory when the program exits?
There's no requirement within the C standard that an OS exist, let alone that it recover un-freed memory. It's possible that some minimalist OSes might not clean up after you. Similarly, if your program runs within a scripting environment (i.e. CGI), or it's etched into a chip (in which case you probably wouldn't want your program terminating), then you might have issues later on.

Answer 4

Indeed a program's memory allocations are freed automatically when the process terminates. However, in the case of a function call who receives an exception before a free() or delete call within that function's code block, the memory will not be freed unless it is referenced by a smart pointer or object of some sort. One recommended option to have allocated memory freed automatically is to use std::shared_ptr, as follows:
void BadFunction(){
char *someMemory = (char *)malloc(1024);
DoSomethingThatMakesAnException();
delete someMemory;// This never gets called!
}
void GoodFunction(){
std::shared_ptr<char> someMemory = std::shared_ptr<char>((char *)malloc(1024));
DoSomethingThatMakesAnException();
// someMemory is freed automatically, even on exception!
}