答案：文章介绍C++内存池与自定义分配器的实现，通过预分配内存块管理小对象分配，提升性能。核心为MemoryPool类实现O(1)分配释放，减少碎片；PoolAllocator模板使STL容器兼容内存池，示例展示其在std::vector中的应用，强调对齐、静态池管理及适用场景。
在C++中，频繁调用
new和
delete或
malloc与
free进行小对象分配会带来显著的性能开销，主要源于系统调用、内存碎片以及对齐处理。为解决这一问题，内存池（Memory Pool）结合自定义分配器（Custom Allocator）是一种高效方案。本文将带你从零实现一个简单的C++内存池，并开发配套的STL兼容分配器。
内存池基本原理
内存池预先分配一大块连续内存，按固定大小切分为多个槽（slot），每次分配只需返回一个空闲槽，释放时将其重新标记为空闲。这种方式避免了操作系统频繁介入，极大提升小对象分配效率。
核心特点：
- 固定块大小，适合频繁分配/释放同类对象
- 分配与释放时间复杂度为 O(1)
- 减少内存碎片，提升缓存局部性
简易内存池实现
以下是一个支持固定大小对象的内存池类：
立即学习“C++免费学习笔记（深入）”；
// MemoryPool.h
class MemoryPool {
private:
struct Block {
Block* next;
};
Block* freeList;
char* memory;
size_t blockSize;
size_t poolSize;
public:
MemoryPool(size_t count, size_t size)
: blockSize((size + alignof(Block) - 1) / alignof(Block) * alignof(Block)),
poolSize(count), freeList(nullptr) {
memory = new char[blockSize * count];
initializePool();
}
~MemoryPool() {
delete[] memory;
}
void* allocate() {
if (!freeList) return nullptr;
Block* block = freeList;
freeList = freeList->next;
return block;
}
void deallocate(void* p) {
Block* block = static_cast
block->next = freeList;
freeList = block;
}
private:
void initializePool() {
for (size_t i = 0; i
Block* block = reinterpret_cast
block->next = freeList;
freeList = block;
}
}
};
STL兼容的自定义分配器
要让STL容器（如
std::vector、
std::list）使用内存池，需实现符合Allocator要求的模板类。 // PoolAllocator.h
template
class PoolAllocator {
public:
using value_type = T;
using pointer = T*;
using const_pointer = const T*;
using reference = T&;
using const_reference = const T&;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
template
struct rebind {
using other = PoolAllocator;
};
PoolAllocator() {
if (!pool) {
pool = new MemoryPool(N, sizeof(T));
}
}
~PoolAllocator() = default;
template
PoolAllocator(const PoolAllocator&) {}
pointer allocate(size_type n) {
if (n == 1) {
return static_cast
}
throw std::bad_alloc();
}
void deallocate(pointer p, size_type n) {
if (n == 1) {
pool->deallocate(p);
}
}
template
void construct(U* p, Args&&... args) {
new(p) U(std::forward
}
void destroy(pointer p) {
p->~T();
}
static MemoryPool* pool;
};
template
MemoryPool* PoolAllocator
使用示例
将自定义分配器用于
std::vector：
#include
struct Point {
float x, y;
Point(float x = 0, float y = 0) : x(x), y(y) {}
};
int main() {
using PoolVec = std::vector
PoolVec points;
points.emplace_back(1.0f, 2.0f);
points.emplace_back(3.0f, 4.0f);
// 所有Point对象由内存池分配
return 0;
}
注意：此分配器仅支持单对象分配（n=1），不适用于需要连续大块内存的场景。
基本上就这些。通过内存池+自定义分配器，你可以显著优化特定场景下的内存性能。关键是理解分配模式，合理设计块大小和池容量。不复杂但容易忽略细节，比如对齐和静态池管理。实际项目中可考虑使用
boost::pool或进一步支持多尺寸池。
