C++标准库中的allocator是负责容器内存分配与释放的组件，默认的std::allocator使用全局new和delete完成内存操作，在一些对性能要求较高的场景下，比如频繁的小对象分配、需要内存池优化的情况，自定义allocator可以更好地控制内存分配逻辑，减少内存碎片，提升分配效率。
C++默认allocator的基本结构
标准库的allocator是一个类模板，核心职责是分配和释放对象所需的内存，同时负责对象的构造和析构。它的基本接口包含以下几个部分：
- allocate函数：负责分配指定数量的对象所需的内存，返回指向内存起始位置的指针
- deallocate函数：负责释放之前分配的内存，需要传入指针和分配的对象数量
- construct函数：在指定的内存位置上构造对象，C++17之后该接口被更通用的std::construct_at替代
- destroy函数：销毁指定位置的对象，C++17之后被std::destroy_at替代
自定义allocator需要遵循和默认allocator相同的接口规范，才能保证和标准容器正常配合使用。
自定义内存分配器的实现步骤
1. 定义allocator类模板
首先我们需要定义一个类模板，模板参数为分配的对象类型T，类内部需要定义一些必要的类型别名，这些类型别名是标准容器适配allocator时需要的。
#include <cstddef>
#include <new>
#include <iostream>
template <typename T>
class MyAllocator {
public:
// 必要的类型别名，符合标准allocator的接口要求
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;
// 默认构造函数
MyAllocator() noexcept = default;
// 拷贝构造函数，允许不同模板参数的allocator之间拷贝
template <typename U>
MyAllocator(const MyAllocator<U>&) noexcept {}
// 分配内存的函数，分配n个T类型对象所需的内存
T* allocate(std::size_t n) {
if (n == 0) {
return nullptr;
}
// 计算需要分配的总字节数，检查是否溢出
if (n > std::size_t(-1) / sizeof(T)) {
throw std::bad_alloc();
}
std::size_t total_bytes = n * sizeof(T);
// 这里使用全局operator new分配内存，实际自定义时可以替换为内存池等逻辑
T* ptr = static_cast<T*>(::operator new(total_bytes));
std::cout << "MyAllocator allocate " << total_bytes << " bytes at " << ptr << std::endl;
return ptr;
}
// 释放内存的函数，释放ptr指向的、之前分配的n个T类型对象的内存
void deallocate(T* ptr, std::size_t n) noexcept {
if (ptr == nullptr || n == 0) {
return;
}
std::size_t total_bytes = n * sizeof(T);
std::cout << "MyAllocator deallocate " << total_bytes << " bytes at " << ptr << std::endl;
// 对应使用全局operator delete释放内存
::operator delete(ptr);
}
// C++17及之前的construct接口，在指定位置构造对象
template <typename U, typename... Args>
void construct(U* p, Args&&... args) {
// 使用placement new在指定内存位置构造对象
::new (static_cast<void*>(p)) U(std::forward<Args>(args)...);
}
// C++17及之前的destroy接口，销毁指定位置的对象
template <typename U>
void destroy(U* p) {
p->~U();
}
// 允许不同模板参数的allocator之间相互比较，通常自定义allocator都相等
template <typename U>
bool operator==(const MyAllocator<U>&) const noexcept {
return true;
}
template <typename U>
bool operator!=(const MyAllocator<U>&) const noexcept {
return false;
}
};
2. 适配标准容器使用
标准容器如std::vector、std::map等都支持传入自定义的allocator作为模板参数，我们只需要在声明容器时指定我们实现的allocator即可。
#include <vector>
#include <map>
#include <string>
int main() {
// 使用自定义allocator的vector，存储int类型
std::vector<int, MyAllocator<int>> vec;
vec.push_back(1);
vec.push_back(2);
vec.push_back(3);
std::cout << "vector elements: ";
for (int num : vec) {
std::cout << num << " ";
}
std::cout << std::endl;
// 使用自定义allocator的map，key为int，value为std::string
std::map<int, std::string, std::less<int>, MyAllocator<std::pair<const int, std::string>>> my_map;
my_map[1] = "hello";
my_map[2] = "world";
std::cout << "map elements: ";
for (const auto& pair : my_map) {
std::cout << pair.first << ":" << pair.second << " ";
}
std::cout << std::endl;
return 0;
}
自定义allocator的注意事项
- allocator的分配和释放必须成对出现，分配的内存大小需要和释放时传入的大小匹配，避免内存泄漏或者非法释放。
- 构造和析构的逻辑要正确，placement new构造的对象必须调用析构函数销毁，不能直接使用free或者delete释放内存。
- 如果allocator需要管理额外的状态，比如内存池的指针，需要注意拷贝和赋值逻辑，标准容器可能会拷贝allocator实例，要确保所有拷贝的allocator实例能正确共享状态。
- 自定义allocator的接口必须完全符合标准要求，否则可能导致容器行为异常或者编译错误。
进阶优化方向
上面实现的是最基础的自定义allocator，实际使用中可以根据需求做更多优化：
- 实现内存池：提前分配一大块内存，小对象分配时直接从内存池中取，释放时放回内存池，减少系统调用次数。
- 对齐优化：针对需要特殊内存对齐的对象，在allocate函数中按照指定对齐方式分配内存，可以使用aligned_alloc等接口。
- 统计功能：在allocate和deallocate中加入统计逻辑，记录内存分配的次数、大小、峰值等，方便排查内存问题。
- 针对不同场景特化：比如针对小对象、大对象分别实现不同的分配逻辑，提升不同场景下的分配效率。
C++_allocator自定义内存分配器内存管理容器适配修改时间：2026-06-18 14:45:17