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

来自cppreference.com
 
C++
 
动态内存管理
未初始化内存算法
受约束的未初始化内存算法
分配器
垃圾收集器支持
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)



 
std::pmr::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 前)
template< class T1, class T2, class NonPair >
void construct( std::pair<T1, T2>* p, NonPair&& non_pair );
 (7) (C++17 起)
(C++20 前)

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

1) 以使用分配器构造的手段在 p 所指示的未初始化内存位置，以 *this 为分配器创建给定类型 U 的对象。此重载只有在 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 及以 yprime 替换 y 的情况。
一旦构造了 xprime 和 yprime，就如同以用 ::new((void *) p) pair<T1, T2>(std::piecewise_construct, std::move(xprime), std::move(yprime)); 于分配的存储构造对偶 p。
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 - 转换成 pair 以进行进一步构造的非对偶实参

返回值

（无）

注解

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

缺陷报告

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

缺陷报告 应用于 出版时的行为 正确行为
LWG 2969 C++17 uses-allocator 构造传递 resource() 传递 *this
LWG 2975 C++17 某些情况下 pair 构造错误地使用第一重载 制约为不接受 pair
LWG 3525 C++11 没有能处理可转换到 pair 的非 pair 类型 添加了重构的重载

参阅

[静态]
 在已分配存储中构造对象
(函数模板)
(C++20 前)
 在分配的存储中构造对象
(std::allocator<T> 的公开成员函数)
来自“https://zh.cppreference.com/mwiki/index.php?title=cpp/memory/polymorphic_allocator/construct&oldid=86606”