自定义STL容器分配器可控制内存分配行为，通过实现allocate和deallocate等接口替换默认std::allocator，用于优化性能或集成内存池；需满足类型定义、内存申请释放及相等性比较等要求，如MemoryPoolAllocator通过空闲链表管理固定大小内存块，提升频繁小对象分配效率，但分配器仅负责原始内存管理，不涉及对象构造与析构。
在C++中，自定义STL容器分配器是一种控制内存分配行为的有效方式。标准模板库（STL）中的容器如 std::vector、std::list 等都允许通过模板参数传入自定义的分配器，从而替换默认的 std::allocator。实现自定义分配器可以优化性能、追踪内存使用或集成特定内存池机制。
自定义分配器的基本要求
要让一个类成为合法的STL分配器，它必须满足一定的接口规范。虽然C++17之后对分配器的要求有所简化，但核心要素仍然包括：
- value_type：被分配对象的类型
- pointer：指向 value_type 的指针类型
- const_pointer：常量指针类型
- reference：引用类型
- const_reference：常量引用类型
- size_type：大小类型（通常是 std::size_t）
- difference_type：指针差值类型
- allocate(size_type n)：分配未初始化的内存块
- deallocate(pointer p, size_type n)：释放已分配的内存
- 支持两个分配器之间的相等性比较（operator== 和 operator!=）
以下是一个最简形式的自定义分配器框架：
立即学习“C++免费学习笔记（深入）”；
template <typename T>
struct MyAllocator {
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;
<pre class='brush:php;toolbar:false;'>// C++17 起推荐添加
using is_always_equal = std::false_type;
template <typename U>
struct rebind {
using other = MyAllocator<U>;
};
MyAllocator() = default;
template <typename U>
MyAllocator(const MyAllocator<U>&) {}
pointer allocate(size_type n) {
return static_cast<pointer>(::operator new(n * sizeof(T)));
}
void deallocate(pointer p, size_type n) {
::operator delete(p);
}
bool operator==(const MyAllocator&) const { return true; }
bool operator!=(const MyAllocator&) const { return false; }};
使用自定义分配器实例化STL容器
定义好分配器后，可以在声明容器时作为模板参数传入：
立即学习“C++免费学习笔记（深入）”；
std::vector<int, MyAllocator<int>> vec; vec.push_back(10); vec.push_back(20);
此时，vector 在增长时会调用 MyAllocator::allocate 来获取内存，并在释放时调用 deallocate。注意：构造对象仍由容器通过 placement new 完成，析构也由容器管理，分配器只负责原始内存的申请与释放。
实现内存池式分配器（进阶示例）
实际应用中，常通过自定义分配器实现内存池以提升性能。下面是一个简化版固定大小内存池分配器的思路：
立即学习“C++免费学习笔记（深入）”；
template <typename T, size_t BlockSize = 4096>
class MemoryPoolAllocator {
private:
struct alignas(T) Block {
char data[sizeof(T)];
};
<pre class='brush:php;toolbar:false;'>union Node {
Block storage;
Node* next;
};
Node* free_list = nullptr;
std::vector<Node*> blocks; // 保存所有大块内存public: using value_type = T; using pointer = T; using const_pointer = const T; using size_type = std::size_t; using is_always_equal = std::false_type;
template <typename U>
struct rebind {
using other = MemoryPoolAllocator<U, BlockSize>;
};
MemoryPoolAllocator() = default;
template <typename U>
MemoryPoolAllocator(const MemoryPoolAllocator<U, BlockSize>&) {}
pointer allocate(size_type n) {
if (n != 1) throw std::bad_alloc();
if (!free_list) {
expand_pool();
}
Node* node = free_list;
free_list = free_list->next;
return reinterpret_cast<pointer>(node);
}
void deallocate(pointer p, size_type n) {
if (n != 1) return;
Node* node = reinterpret_cast<Node*>(p);
node->next = free_list;
free_list = node;
}
bool operator==(const MemoryPoolAllocator&) const { return true; }
bool operator!=(const MemoryPoolAllocator&) const { return false; }private: void expand_pool() { Node* block = new Node[BlockSize]; blocks.push_back(block);
for (size_t i = 0; i < BlockSize - 1; ++i) {
block[i].next = &block[i + 1];
}
block[BlockSize - 1].next = nullptr;
free_list = block;
}public: ~MemoryPoolAllocator() { for (auto b : blocks) { delete[] b; } } };
这个分配器预先分配一大块内存，维护空闲链表，适用于频繁创建销毁小对象的场景，避免频繁调用系统 malloc/free。
注意事项与最佳实践
实现自定义分配器时需注意以下几点：
- 确保 allocate 返回的是未初始化的原始内存，不要在此构造对象
- 不要在 deallocate 中调用析构函数，对象的析构由容器完成
- 若多个线程使用同一类型的分配器实例，需自行保证线程安全
- C++17起，如果分配器具有状态（如持有内存池指针），应将 is_always_equal 设为 false_type
- 不同容器对分配器的使用频率不同，vector 主要在扩容时调用，map/set 每插入一个节点都会调用
基本上就这些。通过合理设计分配器，可以显著改善程序的内存性能和可预测性。不复杂但容易忽略的是分配器的语义边界——它只管内存，不管对象生命周期。
