std::uses_allocator_construction_args

定义于

内存

T 不是 std::pair 的特化

自 C++20 起

// 1)
template< class T, class Alloc, class... Args >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    Args&&... args) noexcept;

T 是 std::pair 的特化

自 C++20 起

// 2)
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;
// 3)
template< class T, class Alloc >
constexpr auto uses_allocator_construction_args( const Alloc& alloc ) noexcept;
// 4)
template< class T, class Alloc, class U, class V >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    U&& u, V&& v) noexcept;
// 6)
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;
// 7)
template< class T, class Alloc, class U, class V >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    std::pair<U, V>&& pr ) noexcept;
//9)
template< class T, class Alloc, class NonPair >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    NonPair&& non_pair ) noexcept;

自 C++23 起

// 5)
template< class T, class Alloc, class U, class V >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    std::pair<U, V>& pr ) noexcept;
// 8)
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;

准备通过使用分配器构造来创建给定类型 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_; // 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。

参数

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

返回值

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

示例

本节不完整

备注

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

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

缺陷报告

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

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