std::uses_allocator_construction_args

< cpp‎ | memory
 
 
工具库
通用工具
日期和时间
函数对象
格式化库 (C++20)
(C++11)
关系运算符 (C++20 中弃用)
整数比较函数
(C++20)
swap 与类型运算
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
常用词汇类型
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)

初等字符串转换
(C++17)
(C++17)
 
动态内存管理
智能指针
(C++11)
(C++11)
(C++11)
(C++17 前)
(C++11)
分配器
uses_allocator_construction_args
(C++20)
内存资源
未初始化存储
未初始化内存算法
有制约的未初始化内存算法
垃圾收集支持
杂项
(C++20)
(C++11)
(C++11)
C 库
低层内存管理
 
定义于头文件 <memory>
T 不是 std::pair 的特化
template< class T, class Alloc, class... Args >

constexpr std::tuple</*see below*/> uses_allocator_construction_args(

    const Alloc& alloc, Args&&... args) noexcept;
(1) (C++20 起)
Tstd::pair 的特化
template< class T, class Alloc, class Tuple1, class Tuple2 >

constexpr std::tuple</*see below*/> uses_allocator_construction_args(

    const Alloc& alloc, std::piecewise_construct_t, Tuple1&& x, Tuple2&& y) noexcept;
(2) (C++20 起)
template< class T, class Alloc >

constexpr std::tuple</*see below*/> uses_allocator_construction_args(

    const Alloc& alloc ) noexcept;
(3) (C++20 起)
template< class T, class Alloc, class U, class V >

constexpr std::tuple</*see below*/> uses_allocator_construction_args(

    const Alloc& alloc, U&& u, V&& v) noexcept;
(4) (C++20 起)
template< class T, class Alloc, class U, class V >

constexpr std::tuple</*see below*/> uses_allocator_construction_args(

    const Alloc& alloc, const std::pair<U,V>& pr) noexcept;
(5) (C++20 起)
template< class T, class Alloc, class U, class V >

constexpr std::tuple</*see below*/> uses_allocator_construction_args(

    const Alloc& alloc, std::pair<U,V>&& pr) noexcept;
(6) (C++20 起)

准备以使用分配器构造的手段创建给定类型 T 对象所需的参数列表。

1) 此重载仅若 T 不是 std::pair 的特化才参与重载决议。返回按下列方式确定的 std::tuple
2) 此重载仅若 Tstd::pair 的特化才参与重载决议。对于 T = std::pair<T1, T2> ,等价于
return std::make_tuple( std::piecewise_construct,
    std::apply( [&alloc](auto&&... args1) {
            return std::uses_allocator_construction_args<T1>( alloc,
                       std::forward<decltype(args1)>(args1)...);
        }, std::forward<Tuple1>(x)),
    std::apply( [&alloc](auto&&... args2) {
            return std::uses_allocator_construction_args<T2>( alloc,
                    std::forward<decltype(args2)>(args2)...);
        }, std::forward<Tuple2>(y))
    );
3) 此重载仅若 Tstd::pair 的特化才参与重载决议。等价于
return std::uses_allocator_construction_args<T>(alloc,
    std::piecewise_construct, std::tuple<>{}, std::tuple<>{}
);
4) 此重载仅若 Tstd::pair 的特化才参与重载决议。等价于
return std::uses_allocator_construction_args<T>( alloc,
    std::piecewise_construct,
    std::forward_as_tuple(std::forward<U>(u)),
    std::forward_as_tuple(std::forward<V>(v))
);
5) 此重载仅若 Tstd::pair 的特化才参与重载决议。等价于
return std::uses_allocator_construction_args<T>( alloc,
    std::piecewise_construct,
    std::forward_as_tuple(pr.first),
    std::forward_as_tuple(pr.second)
);
6) 此重载仅若 Tstd::pair 的特化才参与重载决议。等价于
return std::uses_allocator_construction_args<T>( alloc,
    std::piecewise_construct,
    std::forward_as_tuple(std::move(pr).first),
    std::forward_as_tuple(std::move(pr).second));

参数

alloc - 使用的分配器。
args - 传递给 T 构造函数的参数。
x - 传递给 T 的 .first 的构造函数的参数 tuple
y - 传递给 T 的 .second 的构造函数的参数 tuple
u - 传递给 T 的 .first 的构造函数的单个参数。
v - 传递给 T 的 .second 的构造函数的单个参数。
pr - pair ,将其 .first 传递给 T.first 的构造函数,并将其 .second 传递给 T.second 的构造函数的

返回值

适合于传递给 T 构造函数的参数的 std::tuple

示例

注意

重载 (2-6) 提供传入 std::pair 的分配器传播,它们不支持前导分配器或尾随分配器约定(不同于如使用前导分配器约定的 std::tuple )。

参阅

检查指定的类型是否支持使用分配器的构造
(类模板)
以使用分配器构造的手段创建给类型的对象
(函数模板)
以使用分配器构造的手段在指定的内存位置创建给定类型的对象
(函数模板)