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 的特化时，此重载才会参与重载解析。对于 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) 只有当 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_; // exposition only
    NonPair&     u_;     // exposition only
 
    constexpr reconstruct(const std::remove_cv<T>& p) const // exposition only
    {
        return std::make_obj_using_allocator<std::remove_cv<T>>(alloc_, p);
    }
 
    constexpr reconstruct(std::remove_cv<T>&& p) const // exposition only
    {
        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。

[edit] 参数

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

[edit] 返回值

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

[edit] 备注

重载 (2-9) 提供了对 std::pair 的分配器传播，std::pair 不支持前置分配器或后置分配器调用约定（与例如 std::tuple 不同，std::tuple 使用前置分配器约定）。

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

[edit] 示例

[edit] 缺陷报告

以下行为更改缺陷报告已追溯应用于之前发布的 C++ 标准。

DR	应用于	发布的行为	正确的行为
LWG 3525	C++20	没有重载可以处理可转换为 `pair` 的非 `pair` 类型	添加了重建重载

[edit] 另请参阅

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

编译器支持
独立和托管
语言
标准库
标准库头文件
命名要求
功能测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用实用程序库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
执行支持库 (C++26)
技术规范
符号索引
外部库

cppreference.com

命名空间

变体

视图

操作