std::scoped_allocator_adaptor<OuterAlloc,InnerAlloc...>::construct

// 1)
template < class T, class... Args >
void construct( T* p, Args&&... args );

直到 C++20

// 2)
template< class T1, class T2, class... Args1, class... Args2 >
void construct( std::pair<T1, T2>* p,
                std::piecewise_construct_t,
                std::tuple<Args1...> x,
                std::tuple<Args2...> y );
// 3)
template< class T1, class T2 >
void construct( std::pair<T1, T2>* p );
// 4)
template< class T1, class T2, class U, class V >
void construct( std::pair<T1, T2>* p, U&& x, V&& y );
// 5)
template< class T1, class T2, class U, class V >
void construct( std::pair<T1, T2>* p, const std::pair<U, V>& xy );
// 6)
template< class T1, class T2, class U, class V >
void construct( std::pair<T1, T2>* p, std::pair<U, V>&& xy );
// 7)
template< class T1, class T2, class NonPair >
void construct( std::pair<T1, T2>* p, NonPair&& non_pair );

使用 OuterAllocator 和提供的构造函数参数，在 `p` 指向的已分配但未初始化的存储中构造一个对象。如果对象是本身使用分配器的类型，或者它是 std::pair，则将 InnerAllocator 传递给被构造的对象。

首先，通过调用 `this->outer_allocator()` 来检索最外层的分配器 OUTERMOST，然后对该调用的结果递归调用 outer_allocator() 成员函数，直到达到没有此类成员函数的分配器。

将 OUTERMOST_ALLOC_TRAITS(x) 定义为 `std::allocator_traits<std::remove_reference_t<decltype(OUTERMOST(x))>>`

1. 通过在 `p` 指示的未初始化内存位置使用 `OUTERMOST` 作为分配器，通过 uses-allocator 构造来创建给定类型 T 的对象。在调整为 T 的构造函数所期望的 uses-allocator 约定后，调用 `OUTERMOST_ALLOC_TRAITS(*this)::construct`。

此重载仅在 U 不是 std::pair 的特化时才参与重载解析 (直到 C++20)
等同于

std::apply(
    [p,this](auto&&... newargs) {
        OUTERMOST_ALLOC_TRAITS(*this)::construct(
            OUTERMOST(*this), p, std::forward<decltype(newargs)>(newargs)...);
    },
    std::uses_allocator_construction_args(
        inner_allocator(),
        std::forward<Args>(args)...
    )
);

 (自 C++20 起)

2. 首先，如果 T1 或 T2 是分配器感知的，则根据以下三条规则修改元组 x 和 y，以包含适当的内部分配器，从而得到两个新元组 xprime 和 yprime

   2a) 如果 T1 不是分配器感知的 (`std::uses_allocator<T1, inner_allocator_type>::value == false`)，则 xprime 为 `std::tuple<Args1&&...>(std::move(x))`。(此外，还要求 `std::is_constructible<T1, Args1...>::value == true`)。

   2b) 如果 T1 是分配器感知的 (`std::uses_allocator<T1, inner_allocator_type>::value == true`)，并且其构造函数接受一个分配器 ta

std::is_constructible<T1, std::allocator_arg_t,
    inner_allocator_type&, Args1...>::value == true

则 xprime 为

std::tuple_cat(std::tuple<std::allocator_arg_t, inner_allocator_type&>(
    std::allocator_arg, inner_allocator()
    ),
    std::tuple<Args1&&...>(std::move(x)))

2c) 如果 T1 是分配器感知的 (`std::uses_allocator<T1, inner_allocator_type>::value == true`)，并且其构造函数将分配器作为最后一个参数

std::is_constructible<T1, Args1..., inner_allocator_type&>::value == true

则 xprime 为

std::tuple_cat(std::tuple<Args1&&...>(std::move(x)),
    std::tuple<inner_allocator_type&>(inner_allocator()))

相同的规则适用于 T2，并将 y 替换为 yprime。一旦构造了 xprime 和 yprime，则通过调用构造对 p，即

std::allocator_traits<O>::construct( OUTERMOST,
                                    p,
                                    std::piecewise_construct,
                                    std::move(xprime),
                                    std::move(yprime) );

3. 等同于

construct(p, std::piecewise_construct, std::tuple<>(), std::tuple<>())

，也就是说，如果对的成员类型接受它们，则将内部分配器传递给对的成员类型。

4. 等同于

construct(p, std::piecewise_construct, std::forward_as_tuple(std::forward<U>(x)),
                                       std::forward_as_tuple(std::forward<V>(y)))

5. 等同于

construct(p, std::piecewise_construct, std::forward_as_tuple(xy.first),
                                       std::forward_as_tuple(xy.second))

6. 等同于

construct(p, std::piecewise_construct,
             std::forward_as_tuple(std::forward<U>(xy.first)),
             std::forward_as_tuple(std::forward<V>(xy.second)))

7. 此重载仅在给定暴露-仅函数模板时才参与重载解析

template< class A, class B >
void /*deduce-as-pair*/( const std::pair<A, B>& );

，`/*deduce-as-pair*/(non_pair)` 在被视为未求值操作数时是格式错误的。
等同于 `construct<T1, T2, T1, T2>(p, std::forward<NonPair>(non_pair));`。

 (直到 C++20)

参数

p - 指向已分配但未初始化的存储的指针
args... - 要传递给 T 的构造函数的构造函数参数
x - 要传递给 T1 的构造函数的构造函数参数
y - 要传递给 T2 的构造函数的构造函数参数
xy - 其两个成员是 T1 和 T2 的构造函数参数的对
non_pair - 要转换为对以进行进一步构造的非对参数

返回值

(无)

备注

此函数（通过 std::allocator_traits）会被任何分配器感知的对象（例如 std::vector）调用，该对象被赋予了 std::scoped_allocator_adaptor 作为要使用的分配器。由于 inner_allocator 本身是 std::scoped_allocator_adaptor 的实例，因此当通过此函数构造的分配器感知的对象开始构造自己的成员时，也将调用此函数。

缺陷报告

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

DR	应用于	发布时的行为	正确行为
LWG 2975	C++11	在某些情况下，第一个重载被错误地用于对构造	受限于不接受对
P0475R1	C++11	对的 piecewise 构造可能会复制参数	转换为引用元组以避免复制
LWG 3525	C++11	没有重载可以处理可转换为 pair 的非 pair 类型	添加了重构重载