C++ 具名要求：分配器 (Allocator)

封裝訪問/尋址，分配/解分配，以及對象的構造/析構的策略。

可能需要分配或釋放內存的每個標準庫組件，從 std::string、std::vector 和除 std::array 與 std::inplace_vector (C++26 起)以外的(C++11 起)所有容器，到 std::shared_ptr 和 std::function(C++17 前)，都通過分配器 (Allocator) 進行這些操作：分配器是滿足下列要求的類類型對象。

許多分配器要求的實現是可選的，因為所有知分配器容器 (AllocatorAwareContainer) 都通過 std::allocator_traits 訪問分配器，而 std::allocator_traits 提供這些要求的默認實現。

要求

給定

• T，無 const 限定的非引用類型(C++11 前)無 cv 限定的對象類型(C++11 起)
• A，T 類型的分配器 (Allocator) 類型
• a，A 類型的對象
• B，某個無 cv 限定的對象類型 U 的對應分配器 (Allocator) 類型（由重綁定 A 獲得）
• b，B 類型的對象
• p，std::allocator_traits<A>::pointer 類型的值，由調用 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 類型的值

註：

給定

• 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) 類型要麼是有狀態要麼是無狀態的。通常來說，有狀態分配器類型可以有不相等的值，它們代表不同的內存資源，而無狀態分配器類型代表單一內存資源。

無狀態分配器類型的實例始終比較相等。無狀態分配器類型常實現為空類並適合空基類優化。

綴飾指針

當成員類型 pointer 不是原生指針時，它通常被稱為「綴飾指針（fancy pointer）」。這種指針曾為支持分段內存架構而引入，並在當今用於訪問在某些不同於原生指針所訪問的同質虛擬地址空間的地址空間中所分配的對象。綴飾指針的一個實例是映射的不依賴地址指針 boost::interprocess::offset_ptr，它使得在每個進程中映射到不同地址的共享內存和內存映射文件中分配 std::set 一類的基於結點的數據結構變得可行。通過類模板 std::pointer_traits，(C++11 起)可以獨立於提供綴飾指針的分配器而使用它們。能用函數 std::to_address 從綴飾指針獲得裸指針。(C++20 起)

template<class Alloc>
concept /*simple-allocator*/ = requires(Alloc alloc, std::size_t n)
{
    { *alloc.allocate(n) } -> std::same_as<typename Alloc::value_type&>;
    { alloc.deallocate(alloc.allocate(n), n) };  
} && std::copy_constructible<Alloc>
  && std::equality_comparable<Alloc>;

標準庫

下列標準庫組件滿足分配器 (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 << "在 " << std::hex << std::showbase
                  << reinterpret_cast<void*>(p) << std::dec
                  << (alloc ? " 分配 " : " 解分配 ")
                  << sizeof(T) * n << " 个字节\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);
}

在 0x2020c20 分配 32 个字节
在 0x2023c60 分配 64 个字节
在 0x2020c20 解分配 32 个字节
在 0x2023c60 解分配 64 个字节

缺陷報告

下列更改行為的缺陷報告追溯地應用於以前出版的 C++ 標準。