命名空间
变体
操作

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

来自 cppreference.cn
 
C++
 
内存管理库
(仅为说明目的*)
未初始化内存算法
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)
(C++20)
受约束的未初始化
内存算法
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20) 
(C++20)
C 库

分配器
(C++11)
(C++23)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20) 
(C++11)
(C++17)
内存资源
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
垃圾回收支持
(C++11)(直到 C++23)
(C++11)(直到 C++23)
(C++11)(直到 C++23)
(C++11)(直到 C++23)
(C++11)(直到 C++23)
(C++11)(直到 C++23)
未初始化存储
(直到 C++20*)
(直到 C++20*)
(直到 C++20*)
显式生命周期管理
(C++23)(C++23)
 
std::scoped_allocator_adaptor
 
定义于头文件 <scoped_allocator>
template< class T, class... Args >
void construct( T* p, Args&&... args );
 (1)
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++20)
template< class T1, class T2 >
void construct( std::pair<T1, T2>* p );
 (3) (直到 C++20)
template< class T1, class T2, class U, class V >
void construct( std::pair<T1, T2>* p, U&& x, V&& y );
 (4) (直到 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++20)
template< class T1, class T2, class U, class V >
void construct( std::pair<T1, T2>* p, std::pair<U, V>&& xy );
 (6) (直到 C++20)
辅助函数模板
template < class T, class... Args >
std::tuple</* 见下方 */> /*concat-args*/( std::tuple<Args...>&& tup );
 (7) (仅为说明目的*)
(直到 C++20)

在 p 指向的已分配但未初始化的存储中，使用外部分配器和提供的构造函数实参构造对象。如果对象类型本身使用分配器，或者如果是 std::pair(直到 C++20)，则将内部分配器向下传递给构造的对象。

1) 通过使用分配器构造，在由 p 指示的未初始化内存位置，使用最外层分配器构造类型 T 的对象。

给定 std::uses_allocator<T, inner_allocator_type>::value 为 uses_inner

此重载仅在 T 不是 std::pair 的特化时参与重载决议。

 (直到 C++20)

等效于 std::apply
(
    [p, this](auto&&... newargs)
    {
        outermost-construct
            (p, std::forward<decltype(newargs)>(newargs)...);
    },
    std::uses_allocator_construction_args
        (inner_allocator(), std::forward<Args>(args)...)
); 。

 (自 C++20 起)
2-6) 通过使用分配器构造，在由 p 指示的未初始化内存位置，使用最外层分配器构造 std::pair 对象。
2) 设 xprime 为 concat-args <T1>(std::move(x))，yprime 为 concat-args <T2>(std::move(y))，调用 outermost-construct (p, std::piecewise_construct, std::move(xprime), std::move(yprime))。
3) 等效于 construct(p, std::piecewise_construct, std::tuple<>(), std::tuple<>());。
4-6) 等效于 construct(p, std::piecewise_construct,
          std::forward_as_tuple(xarg), std::forward_as_tuple(yarg));，其中 xarg 和 yarg 定义如下
 重载  xarg yarg
(4) std::forward<U>(x) std::forward<V>(y)
(5) xy.first xy.second
(6) std::forward<U>(xy.first) std::forward<V>(xy.second)
7) 合并 tup 中包含的实参和类型为 T 的对象的使用分配器构造所需的额外实参。
给定 std::uses_allocator<T, inner_allocator_type>::value 为 uses_inner

目录

[编辑] 参数

p - 指向已分配但未初始化的存储的指针
args - 传递给 T 的构造函数的构造函数实参
x - 传递给 T1 的构造函数的构造函数实参
y - 传递给 T2 的构造函数的构造函数实参
xy - 其两个成员是 T1 和 T2 的构造函数实参的 pair
tup - 要合并的实参

[编辑] 注解

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

[编辑] 缺陷报告

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

DR 应用于 已发布时的行为 正确的行为
LWG 2203 C++11 内部分配器通过值初始化获得
inner_allocator_type 对象		 通过调用 inner_allocator() 获得
LWG 2511
(P0475R1)		 C++11 concat-args 可能复制 std::tuple 的元素 消除了所有元素复制操作
LWG 2586 C++11 仅检查来自
inner_allocator_type 右值的构造		 检查来自非 const
inner_allocator_type 左值的构造，改为
LWG 2975 C++11 重载 (1) 未受约束 约束为拒绝 std::pair

[编辑] 参见

[静态]
 在已分配的存储中构造对象
(函数模板) [编辑]
(直到 C++20)
 在已分配的存储中构造对象
(std::allocator<T> 的公共成员函数) [编辑]
Retrieved from "https://cppreference.cn/mwiki/index.php?title=cpp/memory/scoped_allocator_adaptor/construct&oldid=177662"