std::pmr::polymorphic_allocator<T>::construct

自 C++17 起

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

Since C++17, Until 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 );

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

1. 通过使用分配器构造（uses-allocator construction），在 p 指示的未初始化内存位置创建给定类型 U 的对象，并将 *this 作为分配器。
   仅当 U 不是 std::pair 的特化时，此重载才参与重载解析。 (直到 C++20)

2. 首先，如果 T1 或 T2 是分配器感知的，则根据以下三条规则，修改元组 x 和 y 以包含 this->resource()，生成两个新元组 xprime 和 yprime。

   • 2a) 如果 T1 不是分配器感知的（std::uses_allocator<T1, polymorphic_allocator>::value==false）并且 std::is_constructible<T1, Args1...>::value==true，则 xprime 是未修改的 x。

   • 2b) 如果 T1 是分配器感知的（std::uses_allocator<T1, polymorphic_allocator>::value==true），并且其构造函数接受分配器标签（std::is_constructible<T1, std::allocator_arg_t, polymorphic_allocator, Args1...>::value==true），则 xprime 是 std::tuple_cat(std::make_tuple(std::allocator_arg, *this), std::move(x))。

   • 2c) 如果 T1 是分配器感知的（std::uses_allocator<T1, polymorphic_allocator>::value==true），并且其构造函数将分配器作为最后一个参数（std::is_constructible<T1, Args1..., polymorphic_allocator>::value==true），则 xprime 是 std::tuple_cat(std::move(x), std::make_tuple(*this))。

   • 2d) 否则，程序格式错误。

   对于 T2 和 y 到 yprime 的替换，应用相同的规则。一旦构造了 xprime 和 yprime，则在分配的存储中构造 pair p，如同 ::new((void *) p) pair<T1, T2>(std::piecewise_construct, std::move(xprime), std::move(yprime));。

3. 等同于 construct(p, std::piecewise_construct, std::tuple<>(), std::tuple<>())，即，如果 pair 的成员类型接受分配器，则将内存资源传递给它们。

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. 仅当给定 exposição-only 函数模板时，此重载才参与重载解析。

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 - pair，其两个成员是 T1 和 T2 的构造函数参数
non_pair - 非 pair 参数，转换为 pair 以进行进一步构造

返回值

(无)

备注

此函数（通过 std::allocator_traits）被任何分配器感知的对象调用，例如 std::pmr::vector（或另一个被指定使用 std::pmr::polymorphic_allocator 作为分配器的 std::vector）。

缺陷报告

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

DR	应用于	发布时的行为	正确行为
LWG 2969	C++17	uses-allocator 构造传递了 resource()	传递 *this
LWG 2975	C++17	在某些情况下，第一个重载被错误地用于 pair 构造	受约束，不得接受 pair
LWG 3525	C++17	没有重载可以处理可转换为 pair 的非 pair 类型	添加了重构重载