C++ STL 空间配置器(Allocators)详解

什么是空间配置器？

空间配置器是STL中负责内存管理的组件，封装了内存分配和释放的细节。STL容器默认使用std::allocator，但开发者可以自定义分配器以满足特定需求。

默认分配器使用示例

#include <vector>
#include <memory> // 包含allocator

int main() {
    // 使用默认分配器的vector
    std::vector<int, std::allocator<int>> numbers;
    
    numbers.push_back(10);
    numbers.push_back(20);
    numbers.push_back(30);
    
    // 显式使用分配器
    std::allocator<int> alloc;
    int* p = alloc.allocate(1);
    alloc.construct(p, 100);
    std::cout << *p << std::endl; // 100
    alloc.destroy(p);
    alloc.deallocate(p, 1);
    
    return 0;
}

空间配置器的主要功能

空间配置器提供以下核心功能：

allocate(size_t n)

分配足够存储n个对象的内存块

deallocate(T* p, size_t n)

释放之前分配的内存块

construct(T* p, Args&&... args)

在给定地址构造对象(C++17后弃用)

destroy(T* p)

销毁给定地址的对象(C++17后弃用)

现代C++的变化

在C++17及更高版本中，construct和destroy成员函数已被弃用，取而代之的是std::allocator_traits和通用构造/销毁工具。

自定义分配器应用场景

自定义分配器在特定场景下非常有用：

内存池

减少内存分配开销，提高性能

避免频繁调用系统内存分配
减少内存碎片
提高缓存命中率

共享内存

在进程间共享数据结构

跨进程通信
高效数据共享
避免数据复制

特殊硬件

针对特定硬件的内存分配

对齐内存分配
非易失性内存
GPU内存分配

调试追踪

内存泄漏检测和调试

分配/释放追踪
内存使用统计
边界检查

自定义分配器实现

下面是一个简单内存池分配器的实现示例：

内存池分配器实现

#include <iostream>
#include <vector>
#include <memory>

template <typename T>
class MemoryPoolAllocator {
public:
    using value_type = T;
    
    MemoryPoolAllocator() noexcept = default;
    
    template <typename U>
    MemoryPoolAllocator(const MemoryPoolAllocator<U>&) noexcept {}
    
    T* allocate(std::size_t n) {
        std::cout << "Allocating " << n << " object(s)\n";
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }
    
    void deallocate(T* p, std::size_t n) {
        std::cout << "Deallocating " << n << " object(s)\n";
        ::operator delete(p);
    }
    
    // 可选：实现构造和销毁（C++17后通常不需要）
    template <typename U, typename... Args>
    void construct(U* p, Args&&... args) {
        std::cout << "Constructing object\n";
        new (p) U(std::forward<Args>(args)...);
    }
    
    template <typename U>
    void destroy(U* p) {
        std::cout << "Destroying object\n";
        p->~U();
    }
};

int main() {
    // 使用自定义分配器的vector
    std::vector<int, MemoryPoolAllocator<int>> vec;
    
    std::cout << "添加元素...\n";
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);
    
    std::cout << "Vector内容: ";
    for (int n : vec) {
        std::cout << n << " ";
    }
    std::cout << "\n";
    
    std::cout << "离开作用域，自动销毁...\n";
    return 0;
}

输出示例

添加元素...
Allocating 1 object(s)
Constructing object
Allocating 2 object(s)
Constructing object
Constructing object
Deallocating 1 object(s)
Allocating 4 object(s)
Constructing object
Constructing object
Constructing object
Deallocating 2 object(s)
Vector内容: 10 20 30 
离开作用域，自动销毁...
Destroying object
Destroying object
Destroying object
Deallocating 4 object(s)

最佳实践与注意事项

分配器要求

必须是无状态的（或仔细处理状态）
必须提供value_type类型定义
必须实现allocate和deallocate
比较操作应正确实现

常见陷阱

内存对齐问题
异常安全问题
线程安全问题
状态管理问题

性能优化

使用内存池减少碎片
批量分配提高效率
缓存友好设计
避免不必要的初始化

现代C++特性

C++11：支持有状态分配器
C++17：多态分配器
C++20：constexpr分配器支持
使用allocator_traits

高级应用：多态分配器

C++17引入了多态分配器，允许在运行时切换分配策略：

多态分配器示例

#include <memory_resource>
#include <vector>
#include <iostream>

int main() {
    // 创建内存池资源
    std::pmr::unsynchronized_pool_resource pool;
    
    // 使用内存池的vector
    std::pmr::vector<int> vec{&pool};
    
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);
    
    std::cout << "Vector内容: ";
    for (int n : vec) std::cout << n << " ";
    
    // 创建单调缓冲区资源
    char buffer[1024];
    std::pmr::monotonic_buffer_resource mono_res{buffer, sizeof(buffer)};
    
    // 使用单调缓冲区的vector
    std::pmr::vector<int> temp_vec{&mono_res};
    temp_vec.push_back(100);
    temp_vec.push_back(200);
    
    return 0;
}