我们都被教导必须释放每个已分配的指针。不过，我有点好奇不释放内存的真正代价。在一些明显的情况下，比如在循环内部或线程执行的一部分调用malloc()时，释放是非常重要的，这样就不会有内存泄漏。但是考虑下面两个例子:
首先，如果我有这样的代码:
int main()
{
char *a = malloc(1024);
/* Do some arbitrary stuff with 'a' (no alloc functions) */
return 0;
}
真正的结果是什么?我的想法是进程死亡，然后堆空间也消失了，所以错过对free的调用没有什么坏处(然而，我确实认识到无论如何拥有它对于闭包、可维护性和良好实践的重要性)。我这样想对吗?
Second, let's say I have a program that acts a bit like a shell. Users can declare variables like aaa = 123 and those are stored in some dynamic data structure for later use. Clearly, it seems obvious that you'd use some solution that will calls some *alloc function (hashmap, linked list, something like that). For this kind of program, it doesn't make sense to ever free after calling malloc because these variables must be present at all times during the program's execution and there's no good way (that I can see) to implement this with statically allocated space. Is it bad design to have a bunch of memory that's allocated but only freed as part of the process ending? If so, what's the alternative?
一旦我确定我已经完成了每个分配的块，我通常会释放它。今天，我的程序的入口点可能是main(int argc, char *argv[])，但明天它可能是foo_entry_point(char **args, struct foo *f)，并类型为函数指针。
所以，如果发生这种情况，我现在就有了漏洞。
关于你的第二个问题，如果我的程序输入a=5，我会为a分配空间，或者在后续的a="foo"上重新分配相同的空间。这笔款项将继续分配至:
用户输入'unset a'
我的清理功能被输入，要么服务一个信号，要么用户输入“退出”
我想不出有哪个现代操作系统在进程退出后不回收内存。free()很便宜，为什么不清理一下呢?正如其他人所说，像valgrind这样的工具对于发现您确实需要担心的泄漏非常有用。即使你示例中的块被标记为“仍然可达”，当你试图确保没有泄漏时，它只是输出中的额外噪音。
另一个误区是“如果它在main()中，我就不必释放它”，这是不正确的。考虑以下几点:
char *t;
for (i=0; i < 255; i++) {
t = strdup(foo->name);
let_strtok_eat_away_at(t);
}
如果这发生在fork / daemonizing(理论上永远运行)之前，那么您的程序已经泄漏了255次大小不确定的t。
一个好的，编写良好的程序应该总是自我清理。释放所有内存，刷新所有文件，关闭所有描述符，解除所有临时文件的链接等等。应该在正常终止或接收到各种致命信号时执行此清理功能，除非您想要保留一些文件以便检测崩溃并恢复。
真的，当你去做其他事情的时候，要善待那些不得不维护你的东西的可怜人。递给他们“valgrind clean”:)
It depends on the OS environment the program is running in, as others have already noted, and for long running processes, freeing memory and avoiding even very slow leaks is important always. But if the operating system deals with stuff, as Unix has done for example since probably forever, then you don't need to free memory, nor close files (the kernel closes all open file descriptors when a process exits.)
If your program allocates a lot of memory, it may even be beneficial to exit without "hesitation". I find that when I quit Firefox, it spends several !minutes ! paging in gigabytes of memory in many processes. I guess this is due to having to call destructors on C++ objects. This is actually terrible. Some might argue, that this is necessary to save state consistently, but in my opinion, long-running interactive programs like browsers, editors and design programs, just to mention a few, should ensure that any state information, preferences, open windows/pages, documents etc is frequently written to permanent storage, to avoid loss of work in case of a crash. Then this state-saving can be performed again quickly when the user elects to quit, and when completed, the processes should just exit immediately.
