C++ 空间配置器

C++ 空间配置器（Allocator）

C++ 的 空间配置器（Allocator） 是 STL 中负责内存管理的核心组件，它为容器提供统一的内存分配、释放及对象构造/析构的接口。空间配置器通过抽象内存管理逻辑，使得容器可以独立于具体的内存分配策略，从而实现高效、灵活的资源管理。

---

一、空间配置器的核心作用

1. 内存分配与释放
   管理内存的分配（allocate）和释放（deallocate）。
2. 对象构造与析构
   在已分配的内存上构造对象（construct）和析构对象（destroy）。
3. 解耦容器与底层内存管理
   允许用户自定义内存管理策略（如内存池、共享内存等），而无需修改容器代码。

---

二、标准库中的默认空间配置器：std::allocator

C++ 标准库提供了默认的空间配置器 std::allocator<T>，所有 STL 容器默认使用它。以下是其核心接口：

template <class T>
class allocator {
public:
    T* allocate(size_t n);          // 分配 n 个 T 类型对象的内存
    void deallocate(T* p, size_t n); // 释放内存

    template <class... Args>
    void construct(T* p, Args&&... args); // 在地址 p 构造对象
    void destroy(T* p);                   // 析构 p 指向的对象
};

示例：容器默认使用 std::allocator

#include <vector>
#include <memory>

// 默认使用 std::allocator<int>
std::vector<int> vec; 

// 显式指定分配器
std::vector<int, std::allocator<int>> vec2;

---

三、自定义空间配置器

通过实现符合 Allocator 要求的自定义类，可以灵活控制内存管理策略。例如，实现一个简单的内存池或调试用分配器。

1. 自定义分配器的基本要求

• 必须提供 value_type 类型定义。
• 实现 allocate、deallocate、construct、destroy 等方法。
• 支持分配器的复制与比较（如 operator==）。

2. 示例：统计内存分配的分配器

template <typename T>
class DebugAllocator {
public:
    using value_type = T;

    T* allocate(size_t n) {
        std::cout << "Allocating " << n * sizeof(T) << " bytes\n";
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    void deallocate(T* p, size_t n) {
        std::cout << "Deallocating " << n * sizeof(T) << " bytes\n";
        ::operator delete(p);
    }

    // 默认的 construct 和 destroy 使用 placement new 和显式析构
    template <class... Args>
    void construct(T* p, Args&&... args) {
        new (p) T(std::forward<Args>(args)...);
    }

    void destroy(T* p) {
        p->~T();
    }
};

// 使用自定义分配器
std::vector<int, DebugAllocator<int>> vec;

---

四、C++11 后的增强特性

1. 多态分配器（std::pmr::polymorphic_allocator）

C++17 引入了 std::pmr（多态内存资源）命名空间，允许运行时动态切换内存管理策略。

#include <memory_resource>
#include <vector>

// 使用多态分配器（基于内存池）
std::pmr::monotonic_buffer_resource pool; // 内存池资源
std::pmr::polymorphic_allocator<int> alloc(&pool);

std::pmr::vector<int> vec(alloc); // 使用内存池分配

2. std::scoped_allocator_adaptor

用于容器嵌套时传递分配器到内部容器。例如，vector<vector<T>> 可以统一使用外部分配器。

#include <scoped_allocator>
#include <vector>

using InnerVec = std::vector<int>;
using OuterVec = std::vector<InnerVec, std::scoped_allocator_adaptor<DebugAllocator<InnerVec>>>;

OuterVec vec; // 外层和内层容器均使用 DebugAllocator

---

五、空间配置器的底层机制

1. 分离内存分配与对象构造

• allocate：仅分配原始内存，不调用构造函数。
• construct：通过 定位new(placement new )在已分配内存上构造对象。
• destroy：显式调用析构函数，不释放内存。
• deallocate：释放原始内存。

2. 内存对齐与效率优化

• 分配器需确保内存对齐符合 alignof(T) 要求。
• 高性能分配器（如 SGI STL 的二级分配器）通常通过内存池减少系统调用。

---

六、应用场景

1. 内存池
   避免频繁的 new/delete，提升内存分配效率。
2. 调试与监控
   统计内存使用情况，检测内存泄漏。
3. 特殊内存区域
   在共享内存、栈内存或硬件特定地址分配对象。
4. 多线程优化
   为线程本地存储设计无锁分配器。

---

七、自定义分配器示例：固定大小内存池

template <typename T, size_t BlockSize = 1024>
class PoolAllocator {
public:
    using value_type = T;

    PoolAllocator() {
        // 预分配内存块
        head = new char[BlockSize * sizeof(T)];
        current = head;
    }

    T* allocate(size_t n) {
        if (n != 1 || (current + sizeof(T)) > (head + BlockSize * sizeof(T))) {
            throw std::bad_alloc();
        }
        T* ptr = reinterpret_cast<T*>(current);
        current += sizeof(T);
        return ptr;
    }

    void deallocate(T* p, size_t n) {
        // 简单实现：仅在析构时整体释放
    }

    ~PoolAllocator() {
        delete[] head;
    }

private:
    char* head = nullptr;
    char* current = nullptr;
};

// 使用固定内存池的 vector
std::vector<int, PoolAllocator<int>> vec;

---

八、空间配置器 vs 容器适配器

特性	空间配置器（Allocator）	容器适配器（如 stack、queue）
核心职责	内存管理（分配/释放、构造/析构）	提供特定数据结构接口（LIFO/FIFO）
底层依赖	直接操作内存	基于现有容器（如 deque、vector）
自定义场景	优化内存分配策略	扩展容器行为（如优先级队列）
接口复杂度	需满足 Allocator 概念要求	仅需实现目标数据结构操作

---

九、总结

• 空间配置器是 STL 内存管理的基石，提供灵活的内存控制能力。
• 默认 std::allocator 适用于大多数场景，但可通过自定义分配器优化性能或实现特殊需求。
• C++17 多态分配器 进一步增强了动态内存策略的灵活性。
• 结合内存池、调试工具或硬件特性，可以设计出高效、可靠的自定义分配器。