在C++程序运行过程中，频繁调用new和delete进行动态内存分配会产生额外的性能损耗，同时可能造成内存碎片问题。内存池通过预先分配大块内存并自行管理分配与回收，能有效减少系统调用次数，提升内存操作效率。自定义分配器则允许开发者替换标准容器默认的内存分配逻辑，适配特定的业务场景需求。
C++内存池基础设计
内存池的核心思想是提前向系统申请一块连续的大内存区域，后续的内存分配请求都从这块区域中划分，释放时也不直接归还系统，而是标记为可复用状态。基础的内存池通常包含内存块管理、分配逻辑和回收逻辑三个部分。
内存块结构设计
我们可以将内存池管理的最小单元设计为内存块，每个内存块包含指向下一个空闲块的指针，方便构建空闲链表：
#include <cstddef>
#include <iostream>
// 内存块结构体，用于空闲链表管理
struct MemoryBlock {
MemoryBlock* next; // 指向下一个空闲内存块
};
class MemoryPool {
private:
MemoryBlock* free_list; // 空闲链表头指针
char* memory_chunk; // 预分配的内存块起始地址
size_t block_size; // 单个内存块大小
size_t block_count; // 内存块总数量
public:
// 构造函数，初始化内存池
MemoryPool(size_t block_size, size_t block_count)
: block_size(block_size > sizeof(MemoryBlock) ? block_size : sizeof(MemoryBlock)),
block_count(block_count),
free_list(nullptr),
memory_chunk(nullptr) {
// 预分配连续内存
memory_chunk = new char[this->block_size * this->block_count];
// 初始化空闲链表，将所有内存块串联起来
for (size_t i = 0; i < block_count; ++i) {
MemoryBlock* block = reinterpret_cast<MemoryBlock*>(memory_chunk + i * this->block_size);
block->next = free_list;
free_list = block;
}
}
// 析构函数，释放预分配的内存
~MemoryPool() {
delete[] memory_chunk;
}
// 分配内存
void* allocate() {
if (free_list == nullptr) {
std::cerr << "Memory pool is out of memory" << std::endl;
return nullptr;
}
MemoryBlock* allocated_block = free_list;
free_list = free_list->next;
return allocated_block;
}
// 回收内存
void deallocate(void* ptr) {
if (ptr == nullptr) return;
MemoryBlock* block = reinterpret_cast<MemoryBlock*>(ptr);
block->next = free_list;
free_list = block;
}
};
内存池使用示例
下面演示如何使用上述基础内存池进行内存分配和回收：
int main() {
// 创建内存池，每个块大小为32字节，总共100个块
MemoryPool pool(32, 100);
// 分配内存
void* p1 = pool.allocate();
void* p2 = pool.allocate();
std::cout << "Allocated p1: " << p1 << std::endl;
std::cout << "Allocated p2: " << p2 << std::endl;
// 回收内存
pool.deallocate(p1);
pool.deallocate(p2);
return 0;
}
自定义分配器开发规范
C++标准库允许容器使用自定义分配器，只需要分配器满足特定的接口要求即可。自定义分配器需要定义以下几个核心类型成员和成员函数：
value_type：分配器分配的元素类型allocate(size_t n)：分配n个value_type大小的内存，返回指向内存起始地址的指针deallocate(T* p, size_t n)：释放p指向的内存，n为内存对应的元素数量- 构造函数：通常分配器不需要持有状态，所以构造函数可以是无参的，或者支持拷贝构造
基于内存池的自定义分配器实现
我们可以将前面实现的内存池和自定义分配器结合，让标准容器可以使用我们的内存池进行内存管理：
#include <vector>
#include <cstddef>
// 自定义分配器模板
template <typename T>
class PoolAllocator {
public:
using value_type = T;
// 构造函数，关联内存池
PoolAllocator(MemoryPool* pool) : pool_(pool) {}
// 拷贝构造函数
template <typename U>
PoolAllocator(const PoolAllocator<U>& pool_alloc) : pool_(pool_alloc.pool_) {}
// 分配内存
T* allocate(size_t n) {
if (n != 1) {
// 简化处理，仅支持单个元素分配，实际场景需要处理多元素情况
throw std::bad_alloc();
}
return static_cast<T*>(pool_->allocate());
}
// 释放内存
void deallocate(T* p, size_t n) {
if (n != 1) return;
pool_->deallocate(p);
}
// 允许不同模板实例的分配器互相拷贝
template <typename U>
bool operator==(const PoolAllocator<U>& other) const {
return pool_ == other.pool_;
}
template <typename U>
bool operator!=(const PoolAllocator<U>& other) const {
return !(*this == other);
}
private:
template <typename U>
friend class PoolAllocator;
MemoryPool* pool_;
};
// 使用示例：用自定义分配器的vector
int main() {
MemoryPool pool(sizeof(int), 100);
PoolAllocator<int> alloc(&pool);
std::vector<int, PoolAllocator<int>> vec(alloc);
vec.push_back(1);
vec.push_back(2);
vec.push_back(3);
for (int val : vec) {
std::cout << val << " ";
}
std::cout << std::endl;
return 0;
}
注意事项与优化方向
上述实现是基础示例，实际生产环境中还需要考虑更多场景：
- 内存对齐：分配的内存需要满足对应类型的对齐要求，避免未对齐访问导致的性能问题或错误
- 多线程安全：如果内存池在多线程环境下使用，需要添加互斥锁等同步机制保证操作安全
- 内存块大小适配：可以根据分配的元素类型自动计算合适的内存块大小，不需要手动指定
- 内存池扩容：当内存池中的空闲块耗尽时，可以支持动态扩容，预分配更多的内存块
自定义分配器除了结合内存池使用，还可以用于调试场景，比如在分配和释放时记录日志，统计内存使用峰值，帮助定位内存泄漏问题。
C++memory_poolallocatorcustom_allocator修改时间：2026-06-25 01:33:31