C++ named requirements: Allocator

封装了对象的访问/寻址、分配/释放以及构造/销毁策略。

每个可能需要分配或释放存储空间的标准库组件，从 std::string 、 std::vector 及所有容器 （除 std::array 外 (C++11 起) 和 std::inplace_vector (C++26 起) ，到 std::shared_ptr 及 std::function (C++17 前) ，都是通过 分配器 来实现的：即满足下列要求的类类型对象。

许多分配器要求的实现是可选的，因为所有 AllocatorAwareContainer 都通过 std::allocator_traits 间接访问分配器，而 std::allocator_traits 为这些要求提供了默认实现。

要求

给定

• T ，一个 非const、非引用类型 (C++11 前) 非const对象类型 (C++11 起) (C++17 前) 无cv限定对象类型 (C++17 起) ，
• A ，用于类型 T 的 分配器 类型，
• a ，类型为 A 的对象，
• B ，对应某个无cv限定对象类型 U 的 分配器 类型（通过重新绑定 A 获得），
• b ，类型为 B 的对象，
• p ，类型为 std:: allocator_traits < A > :: pointer 的值，通过调用 std:: allocator_traits < A > :: allocate ( ) 获得，
• cp ，类型为 std:: allocator_traits < A > :: const_pointer 的值，通过从 p 转换获得，
• vp ，类型为 std:: allocator_traits < A > :: void_pointer 的值，通过从 p 转换获得，
• cvp ，类型为 std:: allocator_traits < A > :: const_void_pointer 的值，通过从 cp 或从 vp 转换获得，
• xp ，指向某个无cv限定对象类型 X 的可解引用指针，
• r ，通过表达式 * p 获得的类型为 T 的左值，
• n ，类型为 std:: allocator_traits < A > :: size_type 的值。

注意事项：

1. ↑ 另请参阅下文中的 fancy pointers 。
2. ↑ rebind 仅在分配器为 SomeAllocator<T, Args> 形式的模板时才是可选的（由 std::allocator_traits 提供），其中 Args 是零个或多个额外的模板类型参数。

给定

• x1 与 x2 ，作为（可能不同类型的） X::void_pointer 、 X::const_void_pointer 、 X::pointer 或 X::const_pointer 类型的对象

那么，当且仅当 x1 和 x2 都能通过仅使用这四种类型的 static_cast 序列显式转换为 X::const_pointer 类型的两个对应对象 px1 和 px2 ，且表达式 px1 == px2 的计算结果为 true 时， x1 和 x2 即为 等值指针 。

给定

• w1 与 w2 ，类型为 X::void_pointer 的对象

那么，对于表达式 w1 == w2 和 w1 ! = w2 ，其中一个或两个对象都可以被类型为 X::const_void_pointer 的 等值 对象替换，而语义保持不变。

给定

• p1 与 p2 ，类型为 X::pointer 的对象

那么，对于表达式 p1 == p2 、 p1 ! = p2 、 p1 < p2 、 p1 <= p2 、 p1 >= p2 、 p1 > p2 、 p1 - p2 ，其中一个或两个对象都可以被类型为 X::const_pointer 的 等价值 对象替换，而语义保持不变。

上述要求使得比较 Container 的 iterator 与 const_iterator 成为可能。

有状态与无状态分配器

每个 Allocator 类型要么是 有状态的 ，要么是 无状态的 。通常来说，有状态的分配器类型可以具有不等值，这些值表示不同的内存资源；而无状态的分配器类型则表示单一的内存资源。

无状态分配器类型的实例总是比较相等。无状态分配器类型通常实现为空类，适用于 空基类优化 。

Fancy pointers

当成员类型 pointer 不是原始指针类型时，通常被称为 "fancy pointer" 。这类指针的引入是为了支持分段式内存架构，如今被用于访问分配在非统一虚拟地址空间中的对象，这些地址空间无法通过原始指针直接访问。fancy pointer 的一个典型实例是映射地址无关指针 boost::interprocess::offset_ptr ，它使得在共享内存和内存映射文件中分配基于节点的数据结构（如 std::set ）成为可能，即使这些内存在不同进程中被映射到不同地址。fancy pointers 可以独立于提供它们的分配器使用 ，通过类模板 std::pointer_traits (C++11 起) 。 函数 std::to_address 可用于从 fancy pointer 获取原始指针。 (C++20 起)

标准库

以下标准库组件满足 Allocator 要求：

示例

#include <cstdlib>
#include <iostream>
#include <limits>
#include <new>
#include <vector>
template<class T>
struct Mallocator
{
    typedef T value_type;
    Mallocator() = default;
    template<class U>
    constexpr Mallocator(const Mallocator <U>&) noexcept {}
    [[nodiscard]] T* allocate(std::size_t n)
    {
        if (n > std::numeric_limits<std::size_t>::max() / sizeof(T))
            throw std::bad_array_new_length();
        if (auto p = static_cast<T*>(std::malloc(n * sizeof(T))))
        {
            report(p, n);
            return p;
        }
        throw std::bad_alloc();
    }
    void deallocate(T* p, std::size_t n) noexcept
    {
        report(p, n, 0);
        std::free(p);
    }
private:
    void report(T* p, std::size_t n, bool alloc = true) const
    {
        std::cout << (alloc ? "Alloc: " : "Dealloc: ") << sizeof(T) * n
                  << " bytes at " << std::hex << std::showbase
                  << reinterpret_cast<void*>(p) << std::dec << '\n';
    }
};
template<class T, class U>
bool operator==(const Mallocator <T>&, const Mallocator <U>&) { return true; }
template<class T, class U>
bool operator!=(const Mallocator <T>&, const Mallocator <U>&) { return false; }
int main()
{
    std::vector<int, Mallocator<int>> v(8);
    v.push_back(42);
}

Alloc: 32 bytes at 0x2020c20
Alloc: 64 bytes at 0x2023c60
Dealloc: 32 bytes at 0x2020c20
Dealloc: 64 bytes at 0x2023c60

缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的C++标准。

1. ↑ std::allocator 的成员类型 reference 和 const_reference 分别定义为 T& 和 const T& 。
   • 如果 T 是引用类型，则 reference 和 const_reference 是病式构造，因为无法形成引用的引用（ 引用折叠 在 C++11 中引入）。
   • 如果 T 具有 const 限定，则 reference 和 const_reference 相同，且 address() 的重载集合是病式构造。