自定义allocator用于控制内存分配行为，提升性能、减少碎片或满足特殊内存管理需求。STL容器通过模板参数支持自定义allocator，需提供value_type、allocate/deallocate、construct/destroy等接口。示例中pool_allocator使用静态缓冲区实现内存池，避免频繁系统调用，适用于小对象高效分配。使用时将其作为容器模板参数传入，如vector<int, pool_allocator<int, 64>>。注意该实现共享静态池，多线程需加锁或使用thread_local。C++17后construct/destroy被弃用，推荐allocator_traits统一管理。allocator应无状态且可比较，仅在必要时自定义以避免复杂性。
在C++中，STL容器（如vector、list、map等）默认使用系统提供的内存分配方式，即通过new/delete或malloc/free进行内存管理。但有时我们希望控制内存的分配行为——比如提升性能、减少碎片、使用共享内存或池化内存。这时就可以通过自定义allocator来实现。
为什么需要自定义allocator？
标准库中的容器模板都接受一个可选的allocator类型参数。通过替换默认的std::allocator，我们可以：
- 使用内存池，避免频繁调用系统alloc，提高性能
- 在特定区域（如共享内存、嵌入式设备的固定地址）分配对象
- 调试内存使用，记录分配/释放次数，检测泄漏
- 优化对齐或缓存局部性
自定义allocator的基本要求
要实现一个符合STL规范的allocator，必须满足一定的接口要求。虽然C++17后对allocator的要求有所简化，但仍需提供以下关键成员：
- value_type：被分配类型的别名
- pointer：指向value_type的指针
- const_pointer：常量指针
- reference：引用类型
- const_reference：常量引用
- size_type：大小类型（通常为size_t）
- difference_type：指针差值类型
-
rebind
::other ：模板结构体，用于切换分配类型 - allocate(n)：分配n个对象空间（不构造）
- deallocate(p, n)：释放从p开始的n个对象空间（不析构）
- construct(ptr, args...)：在指定位置构造对象
- destroy(ptr)：显式调用析构函数
注意：allocate只负责分配原始内存，construct负责构造；deallocate只释放内存，destroy负责析构。 立即学习“C++免费学习笔记（深入）”；
一个简单的内存池allocator示例
下面是一个基于静态缓冲区的简单内存池allocator，适用于固定数量的小对象分配：
template<typename T, size_t N = 1024>
class pool_allocator {
public:
using value_type = T;
using pointer = T*;
using const_pointer = const T*;
using reference = T&;
using const_reference = const T&;
using size_type = size_t;
using difference_type = ptrdiff_t;
template<typename U>
struct rebind {
using other = pool_allocator<U, N>;
};
private:
union block {
T data;
block* next;
};
static block pool[N];
static block* free_list;
static bool initialized;
void init_pool() {
if (!initialized) {
for (size_t i = 0; i < N - 1; ++i) {
pool[i].next = &pool[i + 1];
}
pool[N - 1].next = nullptr;
free_list = &pool[0];
initialized = true;
}
}
public:
pool_allocator() { init_pool(); }
template<typename U>
pool_allocator(const pool_allocator<U, N>&) { init_pool(); }
~pool_allocator() = default;
pointer allocate(size_type n) {
if (n != 1 || free_list == nullptr) {
throw std::bad_alloc();
}
block* b = free_list;
free_list = free_list->next;
return reinterpret_cast<pointer>(b);
}
void deallocate(pointer p, size_type n) {
if (p == nullptr) return;
block* b = reinterpret_cast<block*>(p);
b->next = free_list;
free_list = b;
}
template<typename U, typename... Args>
void construct(U* p, Args&&... args) {
new(p) U(std::forward<Args>(args)...);
}
template<typename U>
void destroy(U* p) {
p->~U();
}
bool operator==(const pool_allocator&) const { return true; }
bool operator!=(const pool_allocator&) const { return false; }
};
// 静态成员定义
template<typename T, size_t N>
typename pool_allocator<T, N>::block pool_allocator<T, N>::pool[N];
template<typename T, size_t N>
typename pool_allocator<T, N>::block* pool_allocator<T, N>::free_list = nullptr;
template<typename T, size_t N>
bool pool_allocator<T, N>::initialized = false;如何使用自定义allocator
将自定义allocator作为模板参数传给STL容器即可：
#include <vector>
#include <iostream>
int main() {
// 使用内存池allocator的vector
std::vector<int, pool_allocator<int, 64>> vec;
vec.push_back(10);
vec.push_back(20);
vec.push_back(30);
for (int x : vec) {
std::cout << x << " ";
}
std::cout << "\n";
return 0;
}注意：由于所有实例共享同一个静态池，这种实现不适合多线程环境。实际项目中应加锁或使用线程本地存储（thread_local）。
allocator的设计注意事项
- allocator应是无状态的（stateless），或确保不同实例可比较相等
- 多个容器实例可能使用相同类型的allocator，需保证兼容性
- C++17起，construct和destroy逐渐被废弃，推荐使用std::allocator_traits统一接口
- 若使用placement new，务必手动调用析构函数
- 不要在allocate中调用构造函数，也不要在deallocate中调用析构
基本上就这些。自定义allocator能带来性能优势，但也增加了复杂度。除非有明确需求（如高频小对象分配），否则建议使用默认allocator。理解其原理有助于深入掌握STL底层机制。
