如果程序退出，C ++库实现如何分配内存但不释放它？(How does a C++ library implementation allocate memory but not free it when the program exits?)

 代码很简单： 
 
#include <vector>
int main() {
    std::vector<int> v;
}
 
 然后我在Linux上使用Valgrind构建并运行它： 
 
g++ test.cc && valgrind ./a.out
==8511== Memcheck, a memory error detector
...
==8511== HEAP SUMMARY:
==8511==     in use at exit: 72,704 bytes in 1 blocks
==8511==   total heap usage: 1 allocs, 0 frees, 72,704 bytes allocated
==8511==
==8511== LEAK SUMMARY:
==8511==    definitely lost: 0 bytes in 0 blocks
==8511==    indirectly lost: 0 bytes in 0 blocks
==8511==      possibly lost: 0 bytes in 0 blocks
==8511==    still reachable: 72,704 bytes in 1 blocks
==8511==         suppressed: 0 bytes in 0 blocks
...
==8511== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
 
 这里没有内存泄漏，即使有1个alloc和0个free。 这个问题的答案在Valgrind的常见问题解答中引用了这一段的解释 - 
 
 
 
 许多C ++标准库的实现都使用自己的内存池分配器。 很多被破坏对象的内存不会立即被释放并返回给操作系统，而是保存在池中以供以后重复使用。 
 
 
 我的主要问题是： 
 
 C ++库实现如何实现？ 它是否在后台处理一个单独的进程来处理来自其标准模板的所有分配请求，以便当程序退出时（此处为a.out ），内存不会立即返回给操作系统？ 如果是这样，它什么时候会回馈，如何检查过程确实存在？ 如果不是，幕后背后的“魔力”是什么？ 
 
 另一个问题： 
 
 分配了71 KB。 为什么这个号码？ 
 
 谢谢：） 

The code is fairly simple:
 
#include <vector>
int main() {
    std::vector<int> v;
}
 
Then I build and run it with Valgrind on Linux:
 
g++ test.cc && valgrind ./a.out
==8511== Memcheck, a memory error detector
...
==8511== HEAP SUMMARY:
==8511==     in use at exit: 72,704 bytes in 1 blocks
==8511==   total heap usage: 1 allocs, 0 frees, 72,704 bytes allocated
==8511==
==8511== LEAK SUMMARY:
==8511==    definitely lost: 0 bytes in 0 blocks
==8511==    indirectly lost: 0 bytes in 0 blocks
==8511==      possibly lost: 0 bytes in 0 blocks
==8511==    still reachable: 72,704 bytes in 1 blocks
==8511==         suppressed: 0 bytes in 0 blocks
...
==8511== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
 
Here, there is no memory leak, even though there is 1 alloc and 0 free. The answer to this question quotes this paragraph from Valgrind's FAQ for explanation -
 
 
 
Many implementations of the C++ standard libraries use their own memory pool allocators. Memory for quite a number of destructed objects is not immediately freed and given back to the OS, but kept in the pool(s) for later re-use.
 
 
My main question is: 
 
How does the C++ library implementation achieve that? Does it keep around a separate process in the background that handles all allocation requests from its standard templates, so that when the program exits (a.out here), the memory is not immediately given back to the OS? If so, when will it give back, and how can I check the process indeed exists? If not, what is the "magic" behind the scene?
 
Another question:
 
There is 71 KB allocated. Why this number?
 
Thanks:)

原文：https://stackoverflow.com/questions/45537965