Namespaces
Variants

std:: uses_allocator_construction_args

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
(C++11)
(C++11)
uses_allocator_construction_args
(C++20)
(C++20)
(C++20)
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
定义于头文件 <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 ：
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_; // 仅用于说明
    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 数据成员构造函数的参数元组
y - 传递给 T 的 second 数据成员构造函数的参数元组
u - 传递给 T 的 first 数据成员构造函数的单个参数
v - 传递给 T 的 second 数据成员构造函数的单个参数
pr - 一个 pair，其 first 数据成员将传递给 T 的 first 数据成员构造函数， second 数据成员将传递给 T 的 second 数据成员构造函数
non_pair - 要转换为 std::pair 以进行后续构造的单个参数

返回值

std::tuple ，包含适用于传递给 T 类构造函数的参数。

注释

重载版本 (2-9) 提供了分配器向 std::pair 的传播机制，该类型既不支持前导分配器也不支持后置分配器调用约定（与此不同的是，例如 std::tuple 采用前导分配器约定）。

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

示例

本节内容不完整
原因：缺少示例

缺陷报告

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

缺陷报告 应用于 发布时行为 正确行为
LWG 3525 C++20 无法处理可转换为 pair 的非 pair 类型的重载 已添加重构重载

参见

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