Is it really important to free allocated memory if the program's just about to exit?

Question

I understand that if you're allocating memory to store something temporarily, say in response to a user action, and by the time the code gets to that point again you don't need the memory anymore, you should free the memory so it doesn't cause a leak. In case that wasn't clear, here's an example of when I know it's important to free memory:

#include <stdio.h>
#include <stdlib.h>

void countToNumber(int n)
{
    int *numbers = malloc(sizeof(int) * n);

    int i;
    for (i=0; i<n; i++) {
        numbers[i] = i+1;
    }
    for (i=0; i<n; i++) {
        // Yes, simply using "i+1" instead of "numbers[i]" in the printf would make the array unnecessary.
        // But the point of the example is using malloc/free, so pretend it makes sense to use one here.
        printf("%d ", numbers[i]);
    }
    putchar('\n');

    free(numbers); // Freeing is absolutely necessary here; this function could be called any number of times.
}

int main(int argc, char *argv[])
{
    puts("Enter a number to count to that number.");
    puts("Entering zero or a negative number will quit the program.");

    int n;
    while (scanf("%d", &n), n > 0) {
        countToNumber(n);
    }

    return 0;
}

Sometimes, however, I'll need that memory for the whole time the program is running, and even if I end up allocating more for the same purpose, the data stored in the previously-allocated memory is still being used. So the only time I'd end up needing to free the memory is just before the program exits.

But if I don't end up freeing the memory, would that really cause a memory leak? I'd think the operating system would reclaim the memory as soon as the process exits. And even if it doesn't cause a memory leak, is there another reason it's important to free the memory, provided this isn't C++ and there isn't a destructor that needs to be called?

For example, is there any need for the free call in the below example?

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
    void *ptr = malloc(1024);
    // do something with ptr
    free(ptr);
    return 0;
}

In that case the free isn't really inconvenient, but in cases where I'm dynamically allocating memory for structures that contain pointers to other dynamically-allocated data, it would be nice to know I don't need to set up a loop to do it. Especially if the pointer in the struct is to an object with the same struct, and I'd need to recursively delete them.

Answer 1

Generally, the OS will reclaim the memory, so no, you don't have to free() it. But it is really good practice to do it, and in some cases it may actually make a difference. Couple of examples:

• You execute your program as a subprocess of another process. Depending on how that is done (see comments below), the memory won't be freed until the parent finishes. If the parent never finishes, that's a permanent leak.
• You change your program to do something else. Now you need to hunt down every exit path and free everything, and you'll likely forget some.
• Reclaiming the memory is of OS' volition. All major ones do it, but if you port your program to another system it may not.
• Static analysis and debug tools work better with correct code.
• If the memory is shared between processes, it may only be freed after all processes terminate, or possibly not even then.

---

By the way, this is just about memory. Freeing other resources, such as closing a file (fclose()) is much more important, as some OSes (Windows) don't properly flush the stream.