封装访问/寻址，分配/解分配，以及对象的构造/析构的策略。

可能需要分配或释放内存的每个标准库组件，从 std::string、std::vector 和 std::array 以外的所有容器，到 std::shared_ptr 和 std::function，都通过分配器 (Allocator) 进行这些操作：分配器是满足下列要求的类类型对象。

许多分配器要求的实现是可选的，因为所有知分配器类，包括标准库容器，都通过 std::allocator_traits 访问分配器，而 std::allocator_traits 提供这些要求的默认实现。

要求

给定

• T ，无 cv 限定的对象类型
• A ， T 类型的分配器 (Allocator) 类型
• a ， A 类型对象
• B ，某无 cv 限定的对象类型 U 的对应分配器 (Allocator) 类型（由重绑定 A 获得）
• b ， B 类型对象
• p ， allocator_traits<A>::pointer 类型值，由调用 allocator_traits<A>::allocate() 获得
• cp ， allocator_traits<A>::const_pointer 类型值，由从 p 转换获得
• vp ， allocator_traits<A>::void_pointer 类型值，由从 p 转换获得
• cvp ， allocator_traits<A>::const_void_pointer 类型值，由从 cp 或从 vp 转换获得
• xp ，指向某无 cv 限定类型 X 的可解引用的指针
• r ，由表达式 *p 获得的 T 类型左值
• n ， allocator_traits<A>::size_type 类型值

注：

1. ↑ 参阅后述缀饰指针。
2. ↑ rebind 仅若分配器是形式为 SomeAllocator<T, Args> 的模板，其中 Args 是零或更多个额外的类型模板形参才为可选（由 std::allocator_traits 提供）。

给定

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

则 x1 与 x2 为等价值的指针值，当且仅当 x1 与 x2 能用 static_cast ，仅使用这四个类型的序列显式转换成二个对应的 X::const_pointer 类型对象 px1 与 px2 ，而表达式 px1 == px2 求值为 true 。

给定

• 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 。

缀饰指针

当成员类型 pointer 不是原生指针时，它通常被称为“缀饰指针（fancy pointer）”。这种指针曾为支持分段内存架构而引入，并在当今用于访问在某些不同于原生指针所访问的同质虚拟地址空间的地址空间中所分配的对象。缀饰指针的一个实例是映射的不依赖地址指针 boost::interprocess::offset_ptr，它使得在共享内存和在每个进程中映射到不同地址的映射到内存文件中，分配 std::set 一类的基于结点的数据结构可行。通过类模板 std::pointer_traits ， (C++11 起)缀饰指针可以独立于提供它们的分配器而使用。能用函数 std::to_address 从缀饰指针获得裸指针。 (C++20 起)

标准库

下列标准库组件满足分配器 (Allocator) 要求：

示例

#include <cstdlib>
#include <new>
#include <limits>
#include <iostream>
#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_alloc();
 
    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++ 标准。