# std::scoped_allocator_adaptor

< cpp‎ | memory

定义于头文件 `<scoped_allocator>` |  |
template< class OuterAlloc, class... InnerAlloc > class scoped_allocator_adaptor : public OuterAlloc; |  | (C++11 起)

`std::scoped_allocator_adaptor` 类模板是可用于多层容器（ map 的 list 的 set 的 vector 等等）的分配器。它以外层分配器类型 `OuterAlloc` 与零或更多个内层分配器类型 `InnerAlloc...` 实例化。直接以 `scoped_allocator_adaptor` 构造的容器用 `OuterAlloc` 分配其元素，但若元素自身是容器，则它使用首个内存分配器。该容器的元素，若其自身是容器，则使用第二个内存分配器，以此类推。若容器的层级多于内层分配器的数量，则最内层分配器为所有进一步内嵌的容器再度使用。

此适配器的目的是在内嵌容器中正确初始化有状态分配器，例如在所有层次的嵌套容器都必须置于同一共享内存段时。适配器的构造函数接收列表中所有分配器的参数，而每个内嵌容器从适配器按需获得其分配器的状态。

为了 `scoped_allocator_adaptor` 的目的，若下个内层分配器是 `A` ，则任何满足 std::uses_allocator<T,A>::value == true 的类 `T` 参与递归，如同它是容器，另外， std::pair 被当做这种容器，通过 `scoped_allocator_adaptor::construct` 的指定重载。

典型实现保有一个 `std::scoped_allocator_adaptor<InnerAllocs...>` 作为成员对象。

### 成员类型

类型 | 定义
`outer_allocator_type` | OuterAlloc
`inner_allocator_type` | scoped_allocator_adaptor<InnerAllocs...> ，或若 sizeof...(InnerAllocs) == 0 则为 scoped_allocator_adaptor<OuterAlloc>
`value_type` | std::allocator_traits<OuterAlloc>::value_type
`size_type` | std::allocator_traits<OuterAlloc>::size_type
`difference_type` | std::allocator_traits<OuterAlloc>::difference_type
`pointer` | std::allocator_traits<OuterAlloc>::pointer
`const_pointer` | std::allocator_traits<OuterAlloc>::const_pointer
`void_pointer` | std::allocator_traits<OuterAlloc>::void_pointer
`const_void_pointer` | std::allocator_traits<OuterAlloc>::const_void_pointer
`propagate_on_container_copy_assignment` 若 std::allocator_traits<A>::propagate_on_container_copy_assignment::value 对于 `OuterAlloc` 与 `InnerAlloc...` 之中至少一个分配器为 true 则为 std::true_type
`propagate_on_container_move_assignment` 若 {std::allocator_traits<A>::propagate_on_container_move_assignment::value 对于 `OuterAlloc` 与 `InnerAlloc...` 之中至少一个分配器为 true 则为 std::true_type
`propagate_on_container_swap` 若 std::allocator_traits<A>::propagate_on_container_swap::value 对于 `OuterAlloc` 与 `InnerAlloc...` 之中至少一个分配器为 true 则为 std::true_type
`is_always_equal`(C++17) 若 std::allocator_traits<A>::is_always_equal::value 对于 `OuterAlloc` 与 `InnerAlloc...` 中每个分配器为 true 则为 std::true_type
`rebind`
    template< class T >
    struct rebind {
        typedef scoped_allocator_adaptor<
            std::allocator_traits<OuterAlloc>::template rebind_alloc<T>,
            InnerAllocs...
        > other;
    };

### 成员函数

(构造函数) | 创建新的 scoped_allocator_adaptor 实例 (公开成员函数)
(析构函数) | 析构 scoped_allocator_adaptor 实例 (公开成员函数)
operator= | 赋值一个 `scoped_allocator_adaptor` (公开成员函数)
inner_allocator | 获得一个 `inner_allocator` 引用 (公开成员函数)
outer_allocator | 获得一个 `outer_allocator` 引用 (公开成员函数)
allocate | 用外层分配器分配未初始化存储 (公开成员函数)
deallocate | 用外层分配器解分配存储 (公开成员函数)
max_size | 返回外层分配器所支持的最大分配大小 (公开成员函数)
construct | 在分配的存储上构造一个对象，若适合则传递内存分配器至其构造函数 (公开成员函数)
destroy | 析构处于分配的存储的对象 (公开成员函数)
select_on_container_copy_construction | 复制 scoped_allocator_adaptor 与其所有分配器的状态 (公开成员函数)

### 非成员函数

operator==operator!= (C++20 中移除) | 比较两个 scoped_allocator_adaptor 实例 (公开成员函数)

### 推导指引(C++17 起)

### 示例

    #include <vector>
    #include <scoped_allocator>
    #include <boost/interprocess/managed_shared_memory.hpp>
    #include <boost/interprocess/allocators/adaptive_pool.hpp>
    namespace bi = boost::interprocess;
    template<class T> using alloc = bi::adaptive_pool<T,
                                        bi::managed_shared_memory::segment_manager>;
    using ipc_row = std::vector<int, alloc<int>>;
    using ipc_matrix = std::vector<ipc_row, std::scoped_allocator_adaptor<alloc<ipc_row>>>;
    int main ()
    {
       bi::managed_shared_memory s(bi::create_only, "Demo", 65536);

       // 在共享内存中创建 vector 的 vector
       ipc_matrix v(s.get_segment_manager());

       // 对于所有这些附加项，内层 vector 从外层 vector 的 scoped_allocator_adaptor
       // 获得其分配器参数
       v.resize(1); v[0].push_back(1);
       v.emplace_back(2);
       std::vector<int> local_row = {1,2,3};
       v.emplace_back(local_row.begin(), local_row.end());

       bi::shared_memory_object::remove("Demo");
    }

### 参阅

allocator_traits (C++11) | 提供关于分配器类型的信息 (类模板)
uses_allocator (C++11) | 检查指定的类型是否支持使用分配器的构造 (类模板)
allocator | 默认的分配器 (类模板)