内存池通过预分配大块内存并内部管理分配与释放，减少系统调用开销。它适用于频繁创建销毁固定大小对象的场景，提升分配速度与缓存局部性，降低碎片风险。实现上采用空闲链表管理可用槽位，结合placement new进行对象构造。虽然存在不适用变长对象、需手动调用析构等限制，但在游戏、实时系统中仍能显著优化性能。
在高性能C++程序中，频繁调用系统内存分配函数（如new和delete或malloc/free）会带来显著的性能开销。为了减少这种开销，内存池技术被广泛使用。内存池预先分配一大块内存，然后在内部管理小块内存的分配与释放，避免频繁与操作系统交互。
内存池的基本原理
内存池的核心思想是：一次性向操作系统申请一块较大的连续内存空间，之后所有的内存分配请求都从这块空间中划分，不再直接调用系统API。当对象销毁时，内存并不立即归还系统，而是返回到池中供后续复用。
这种方式特别适合以下场景：
- 频繁创建和销毁相同或固定大小的对象
- 对分配速度要求高，延迟敏感的应用（如游戏、实时系统）
- 避免内存碎片，提升缓存局部性
实现一个简单的固定大小内存池
下面是一个针对固定大小对象的简单内存池实现。假设我们要管理大小为sizeof(T)的对象。
立即学习“C++免费学习笔记（深入）”；
#include <iostream>
#include <cstdlib>
<p>template <typename T, size_t BlockSize = 4096>
class MemoryPool {
private:
struct Node {
Node* next;
};</p><pre class='brush:php;toolbar:false;'>union Slot {
T data;
Node node;
};
Slot* memory_;
Node* free_list_;
size_t remaining_;public: MemoryPool() : memory_(nullptr), freelist(nullptr), remaining_(0) { allocateBlock(); }
~MemoryPool() {
while (memory_) {
Slot* next = reinterpret_cast<Slot*>(memory_[BlockSize].node.next);
delete[] reinterpret_cast<char*>(memory_);
memory_ = next;
}
}
T* allocate() {
if (!free_list_) {
allocateBlock();
}
Node* slot = free_list_;
free_list_ = free_list_->next;
return reinterpret_cast<T*>(slot);
}
void deallocate(T* ptr) {
if (ptr) {
Node* slot = reinterpret_cast<Node*>(ptr);
slot->next = free_list_;
free_list_ = slot;
}
}private:
void allocateBlock() {
// 分配一块内存：BlockSize个T + 一个指向下一块的指针
char raw = new char[(BlockSize + 1) sizeof(Slot)];
Slot block = reinterpret_cast
// 将新块链接到已分配块链表头部
block[BlockSize].node.next = memory_;
memory_ = block;
// 将新块中的所有槽位链接到空闲链表
for (size_t i = 0; i < BlockSize - 1; ++i) {
block[i].node.next = &block[i + 1].node;
}
block[BlockSize - 1].node.next = nullptr;
free_list_ = &block[0].node;
remaining_ = BlockSize;
}};
Access Gmail, Calendar, Drive, Docs, and Sheets via the gws CLI or Python.
// 使用示例 struct Point { float x, y; Point(float x = 0, float y = 0) : x(x), y(y) {} };
上面代码的关键点：
- 使用
union在未使用的内存中存储空闲链表指针 - 每次分配一个“块”（Block），包含多个对象槽位
- 空闲对象通过单向链表连接，分配就是取头节点，释放就是插回链表头
- 析构时回收所有分配的大块内存
如何使用这个内存池
结合placement new和显式析构函数来使用内存池：
int main() {
MemoryPool<Point> pool;
<pre class='brush:php;toolbar:false;'>// 分配并构造对象
Point* p1 = pool.allocate();
new(p1) Point(1.0f, 2.0f); // placement new
Point* p2 = pool.allocate();
new(p2) Point(3.0f, 4.0f);
std::cout << "p1: (" << p1->x << ", " << p1->y << ")\n";
std::cout << "p2: (" << p2->x << ", " << p2->y << ")\n";
// 显式调用析构
p1->~Point();
p2->~Point();
// 归还内存
pool.deallocate(p1);
pool.deallocate(p2);
return 0;}
性能优势与注意事项
相比直接使用new/delete，该内存池的优势包括：
- 分配/释放接近O(1)，只需操作链表头
- 内存局部性好，提高缓存命中率
- 减少系统调用次数，降低碎片风险
但也有几点需要注意：
- 不适用于变长对象或大小差异大的对象
- 长期运行可能无法释放内存给系统（除非加回收机制）
- 需手动管理构造与析构（配合placement new）
基本上就这些。这个简易内存池适合学习和小型项目。实际生产中可考虑更成熟的方案，如Google的tcmalloc、Intel的TBB内存池，或Boost.Pool。但对于特定场景，定制内存池仍是提升性能的有效手段。
