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

< cpp‎ | memory‎ | polymorphic allocator

template < class U, class... Args > void construct( U* p, Args&&... args ); | (1) | (C++17 起)
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 ); | (2) | (C++17 起) (C++20 前)
template< class T1, class T2 > void construct( std::pair<T1, T2>* p ); | (3) | (C++17 起) (C++20 前)
template< class T1, class T2, class U, class V > void construct( std::pair<T1, T2>* p, U&& x, V&& y ); | (4) | (C++17 起) (C++20 前)
template< class T1, class T2, class U, class V > void construct( std::pair<T1, T2>* p, const std::pair<U, V>& xy ); | (5) | (C++17 起) (C++20 前)
template< class T1, class T2, class U, class V > void construct( std::pair<T1, T2>* p, std::pair<U, V>&& xy ); | (6) | (C++17 起) (C++20 前)

在 `p` 所指的，分配但未初始化的存储上，以提供的构造函数参数构造一个对象。若对象自身拥有使用分配器的类型，或它是 std::pair ，则传递 `this->resource()` 给被构造的对象。

1) 以使用分配器构造的手段在 p 所指示的未初始化内存位置，以 *this 为分配器创建给定类型 `U` 的对象。此重载仅若 `U` 不是 std::pair 的特化才参与重载决议。 (C++20 前)

2) 首先，若 `T1` 或 `T2` 之一具分配器，则修改 `x` 与 `y` 的 tuple 以包含 `this->resource()` ，产生二个新 tuple `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` 及以 `yprime` 替换 `y` 的情况。 一旦构造了 `xprime` 和 `yprime` ，就如同以用 ::new((void *) p) pair<T1, T2>(std::piecewise_construct, std::move(xprime), std::move(yprime)); 于分配的存储构造 pair `p` 。 3) 等价于 construct(p, std::piecewise_construct, std::tuple<>(), std::tuple<>()) ，即传递memory_resouce 到 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)))
| (C++20 前)

### 参数

p | - | 指向分配而未初始化存储的指针
args... | - | 传递给 `T` 构造函数的构造函数参数
x | - | 传递给 `T1` 构造函数的构造函数参数
y | - | 传递给 `T2` 构造函数的构造函数参数
xy | - | 成员是 `T1` 与 `T2` 构造函数参数的 pair

### 返回值

（无）

### 注意

此函数为任何具分配器对象调用（通过 std::allocator_traits ），例如 std::pmr::vector （或另一个给定了 `std::std::polymorphic_allocator` 作为所用分配器的 std::vector ）。

### 缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

DR | 应用于 | 出版时的行为 | 正确行为
--- | --- | --- | ---
LWG 2969 | C++17 | uses-allocator 构造传递 `resource()` | 传递 `*this`
LWG 2975 | C++17 | 某些情况下 pair 构造错误地使用第一重载 | 制约为不接受 pair

### 参阅

construct [静态] | 在分配的存储构造对象 (函数模板)
construct (C++17 中弃用)(C++20 中移除) | 在分配的存储构造对象 (`std::allocator<T>` 的公开成员函数)