std::uses_allocator_construction_args

在标头 `<memory>` 定义

`T` 不是 std::pair 的特化
template< class T, class Alloc, class... Args > constexpr auto uses_allocator_construction_args( const Alloc& alloc, Args&&... args) noexcept;	(1)	(C++20 起)

`T` 是 std::pair 的特化
template< class T, class Alloc, class Tuple1, class Tuple2 > constexpr auto 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 auto uses_allocator_construction_args( const Alloc& alloc ) noexcept;	(3)	(C++20 起)
template< class T, class Alloc, class U, class V > constexpr auto 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 auto uses_allocator_construction_args( const Alloc& alloc, std::pair<U, V>& pr ) noexcept;	(5)	(C++23 起)
template< class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args( const Alloc& alloc, const std::pair<U, V>& pr ) noexcept;	(6)	(C++20 起)
template< class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args( const Alloc& alloc, std::pair<U, V>&& pr ) noexcept;	(7)	(C++20 起)
template< class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args( const Alloc& alloc, const std::pair<U, V>&& pr ) noexcept;	(8)	(C++23 起)
template< class T, class Alloc, class NonPair > constexpr auto uses_allocator_construction_args( const Alloc& alloc, NonPair&& non_pair ) noexcept;	(9)	(C++20 起)

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

1) 此重载只有在 T 不是 std::pair 的特化时才会参与重载决议。返回按下列方式确定的 std::tuple ：

若 std::uses_allocator_v<T, Alloc> 为 false 而 std::is_constructible_v<T, Args...> 为 true ，则返回 std::forward_as_tuple(std::forward<Args>(args)...)
否则，若 std::uses_allocator_v<T, Alloc> 为 true 而 std::is_constructible_v<T, std::allocator_arg_t, const Alloc&, Args...> 为 true ，则返回 std::tuple<std::allocator_arg_t, const Alloc&, Args&&...>(std::allocator_arg, alloc, std::forward<Args>(args)...)
否则，若 std::uses_allocator_v<T, Alloc> 为 true 而 std::is_constructible_v<T, Args..., const Alloc&> 为 true ，则返回 std::forward_as_tuple(std::forward<Args>(args)..., alloc)
否则，程序非良构

2) 此重载只有在 T 是 std::pair 的特化时才会参与重载决议。对作为 std::pair<T1, T2> 的 T 等价于

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) 此重载只有在 T 是 std::pair 的特化时才会参与重载决议。等价于

return std::uses_allocator_construction_args<T>(alloc,
    std::piecewise_construct, std::tuple<>{}, std::tuple<>{}
);

4) 此重载只有在 T 是 std::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-6) 此重载只有在 T 是 std::pair 的特化时才会参与重载决议。等价于

return std::uses_allocator_construction_args<T>( alloc,
    std::piecewise_construct,
    std::forward_as_tuple(pr.first),
    std::forward_as_tuple(pr.second)
);

7-8) 此重载只有在 T 是 std::pair 的特化时才会参与重载决议。等价于

return std::uses_allocator_construction_args<T>( alloc,
    std::piecewise_construct,
    std::forward_as_tuple(std::get<0>(std::move(pr))),
    std::forward_as_tuple(std::get<1>(std::move(pr)));

9) 此重载只有在 T 是 std::pair 的特化，并且给定仅用于阐释的函数模板

template< class A, class B >
void /*deduce-as-pair*/( const std::pair<A, B>& );

， /*deduce-as-pair*/(non_pair) 在当作不求值操作数时非良构时才会参与重载决议。
令仅用于阐释的类 pair-constructor 定义为

class /*pair-constructor*/ {
    const Alloc& alloc_; // 仅用于阐释
    NonPair&     u_;     // 仅用于阐释
 
    constexpr reconstruct(const std::remove_cv<T>& p) const // 仅用于阐释
    {
        return std::make_obj_using_allocator<std::remove_cv<T>>(alloc_, p);
    }
 
    constexpr reconstruct(std::remove_cv<T>&& p) const // 仅用于阐释
    {
        return std::make_obj_using_allocator<std::remove_cv<T>>(alloc_, std::move(p));
    }
 
public:
    constexpr operator std::remove_cv<T>() const
    {
        return reconstruct(std::forward<NonPair>(u_));
    }
};

此重载等价于 return std::make_tuple(pair_construction); ，其中 pair_construction 是 pair-constructor 类型的值，其 alloc_ 与 u_ 成员分别为 alloc 与 non_pair 。

参数

alloc	-	使用的分配器
args	-	传递给 `T` 构造函数的参数
x	-	传递给 `T` 的 `first` 数据成员的构造函数的参数 `tuple`
y	-	传递给 `T` 的 `second` 数据成员的构造函数的参数 `tuple`
u	-	传递给 `T` 的 `first` 数据成员的构造函数的单个参数
v	-	传递给 `T` 的 `second` 数据成员的构造函数的单个参数
pr	-	将其 `first` 数据成员传递给 `T` 的 `first` 数据成员的构造函数，并将其 `second` 数据成员传递给 `T` 的 `second` 数据成员的构造函数的 `pair`
non_pair	-	转换成 std::pair 以供进一步构造的单个参数

返回值

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

示例

注解

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

在用于使用分配器构造时， pair-constructor 的转换函数首先将提供的参数转换成 std::pair ，然后再以使用分配器构造从该 std::pair 构造结果。

缺陷报告

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

缺陷报告	应用于	出版时的行为	正确行为
LWG 3525	C++20	没有重载能处理可转换成 `pair` 的非 `pair` 类型	添加了重构的重载

参阅

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

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
技术规范
符号索引
外部库

std::uses_allocator_construction_args

参数

返回值

示例

注解

缺陷报告

参阅

导航