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->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)))
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 构造函数参数的 pair
non_pair - 转换成 pair 以进行进一步构造的非 pair 参数

返回值

（无）

注解

此函数为任何具分配器对象调用（通过 std::allocator_traits ），例如 std::pmr::vector （或另一个给定了 std::std::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++17 中弃用)(C++20 中移除)
 在分配的存储构造对象
(std::allocator<T> 的公开成员函数)
来自“https://zh.cppreference.com/mwiki/index.php?title=cpp/memory/polymorphic_allocator/construct&oldid=74053”