`<utility>` 函数

项目
10/14/2023

`as_const`

template <class T> constexpr add_const_t<T>& as_const(T& t) noexcept;
template <class T> void as_const(const T&&) = delete;

返回值

返回 T。

`declval`

template <class T> add_rvalue_reference_t<T> declval() noexcept;  // as unevaluated operand

`exchange`

(C++14) 向对象赋予新值并返回其旧值。

template <class T, class Other = T>
    T exchange(T& val, Other&& new_val)

参数

val
将接收 new_val 的值的对象。

new_val
其值将被复制或移到 val 中的对象。

注解

对于复杂类型，exchange 可避免在移动构造函数可用时复制旧值、避免在新值是临时对象或被移动时复制新值，并且使用任何可用的转换赋值运算符接受任何类型作为新值。 exchange 函数不同于 std::swap，后者的左自变量不会移动或复制到右自变量。

示例

下面的示例说明如何使用 exchange。在实际情况下，exchange 对难以复制的大型对象非常有用：

#include <utility>
#include <iostream>

using namespace std;

struct C
{
   int i;
   //...
};

int main()
{
   // Use brace initialization
   C c1{ 1 };
   C c2{ 2 };
   C result = exchange(c1, c2);
   cout << "The old value of c1 is: " << result.i << endl;
   cout << "The new value of c1 after exchange is: " << c1.i << endl;

   return 0;
}

The old value of c1 is: 1
The new value of c1 after exchange is: 2

`forward`

如果自变量是右值或右值引用，则有条件地将其自变量强制转换为右值引用。这会将自变量的右值状态还原到转发函数，以支持完美转发。

template <class Type>    // accepts lvalues
    constexpr Type&& forward(typename remove_reference<Type>::type& Arg) noexcept

template <class Type>    // accepts everything else
    constexpr Type&& forward(typename remove_reference<Type>::type&& Arg) noexcept

参数

Type
传入 Arg 的值的类型，可能不同于 Arg 的类型。通常由转发函数的模板自变量决定。

Arg
要强制转换的自变量。

返回值

如果传入 Arg 的值最初为右值或右值引用，则返回对 Arg 的右值引用；否则，返回 Arg，而不修改其类型。

备注

你必须指定显式模板参数来调用 forward。

forward 不转发其自变量。而是在其参数最初为右值或右值引用时，通过有条件地将参数强制转换为右值引用，forward 使得编译器能够在得知转发的参数的原始类型后执行重载决策。转发函数的自变量的表面类型可能不同于其原始类型，例如，当 rvalue 用作函数的自变量并绑定到参数名称时；拥有名称可使其成为 lvalue，而无论作为 rvalue 实际存在的值是什么，forward 将还原自变量的 rvalue 状态。

还原自变量原始值的 rvalue 状态以执行重载决策被称为“完美转移”。通过完美转发，模板函数可接受任一引用类型的自变量，并在必要时还原其右值状态以执行正确的重载决策。通过使用完美转发，你可以保留右值的移动语义，而且无需提供仅根据其自变量的引用类型而变化的函数的重载。

from_chars

from_chars_result from_chars(const char* first, const char* last, see below& value, int base = 10);

from_chars_result from_chars(const char* first, const char* last, float& value, chars_format fmt = chars_format::general);

from_chars_result from_chars(const char* first, const char* last, double& value, chars_format fmt = chars_format::general);

from_chars_result from_chars(const char* first, const char* last, long double& value, chars_format fmt = chars_format::general);

`get`

按索引位置或类型从 pair 对象获取元素。

// get reference to element at Index in pair Pr
template <size_t Index, class T1, class T2>
    constexpr tuple_element_t<Index, pair<T1, T2>>&
    get(pair<T1, T2>& Pr) noexcept;

// get reference to element T1 in pair Pr
template <class T1, class T2>
    constexpr T1& get(pair<T1, T2>& Pr) noexcept;

// get reference to element T2 in pair Pr
template <class T2, class T1>
    constexpr T2& get(pair<T1, T2>& Pr) noexcept;

// get const reference to element at Index in pair Pr
template <size_t Index, class T1, class T2>
    constexpr const tuple_element_t<Index, pair<T1, T2>>&
    get(const pair<T1, T2>& Pr) noexcept;

// get const reference to element T1 in pair Pr
template <class T1, class T2>
    constexpr const T1& get(const pair<T1, T2>& Pr) noexcept;

// get const reference to element T2 in pair Pr
template <class T2, class T1>
    constexpr const T2& get(const pair<T1, T2>& Pr) noexcept;

// get rvalue reference to element at Index in pair Pr
template <size_t Index, class T1, class T2>
    constexpr tuple_element_t<Index, pair<T1, T2>>&&
    get(pair<T1, T2>&& Pr) noexcept;

// get rvalue reference to element T1 in pair Pr
template <class T1, class T2>
    constexpr T1&& get(pair<T1, T2>&& Pr) noexcept;

// get rvalue reference to element T2 in pair Pr
template <class T2, class T1>
    constexpr T2&& get(pair<T1, T2>&& Pr) noexcept;

参数

Index
所选择的元素从 0 开始的索引。

T1
第一个 pair 元素的类型。

T2
第二个 pair 元素的类型。

pr
要从中进行选择的对。

备注

每个模板函数都返回对其 pair 参数的元素的引用。

对于索引重载，如果 Index 的值为 0，则这些函数返回 pr.first ；如果 Index 的值为 1，则这些函数返回 pr.second。类型 RI 是返回的元素的类型。

对于不具有 Index 参数的重载，要返回的元素由类型自变量推导。如果 pr 中包含的 T 类型元素的个数不为一个，则调用 get<T>(Tuple) 将生成编译器错误。

示例

#include <utility>
#include <iostream>
using namespace std;
int main()
{
    typedef pair<int, double> MyPair;

    MyPair c0(9, 3.14);

    // get elements by index
    cout << " " << get<0>(c0);
    cout << " " << get<1>(c0) << endl;

    // get elements by type (C++14)
    MyPair c1(1, 0.27);
    cout << " " << get<int>(c1);
    cout << " " << get<double>(c1) << endl;
}

9 3.14
1 0.27

`index_sequence`

template<size_t... I>
    using index_sequence = integer_sequence<size_t, I...>;

`index_sequence_for`

template<class... T>
    using index_sequence_for = make_index_sequence<sizeof...(T)>;

`make_index_sequence`

template<size_t N>
    using make_index_sequence = make_integer_sequence<size_t, N>;

`make_integer_sequence`

template<class T, T N>
    using make_integer_sequence = integer_sequence<T, see below >;

`make_pair`

一种可用来构造 pair 类型对象的模板函数，其中，组件类型将根据作为参数传递的数据类型自动进行选择。

template <class T, class U>
    pair<T, U> make_pair(T& Val1, U& Val2);

template <class T, class U>
    pair<T, U> make_pair(T& Val1, U&& Val2);

template <class T, class U>
    pair<T, U> make_pair(T&& Val1, U& Val2);

template <class T, class U>
    pair<T, U> make_pair(T&& Val1, U&& Val2);

参数

Val1
用于初始化第一个 pair 元素的值。

Val2
用于初始化第二个 pair 元素的值。

返回值

所构造的配对对象：pair<T,U>(Val1, Val2)。

备注

make_pair 可以将 reference_wrapper 类类型的对象转换为引用类型，将衰减数组和函数转换为指针。

在返回的 pair 对象中，T 通过以下方式确定：

如果输入类型 T 为 reference_wrapper<X>，则返回的类型 T 为 X&。
否则，返回的类型 T 为 decay<T>::type。如果不支持 decay 类，则返回的类型 T 与输入类型 T 相同。

返回的类型 U 以类似的方式通过输入类型 U 来确定。

make_pair 的优势之一在于要存储的对象类型由编译器自动确定，而不必显式指定。使用 make_pair 时请不要使用显式模板自变量（如 make_pair<int, int>(1, 2)），因为它很详细，会增加复杂的 rvalue 引用问题，这可能会导致编译失败。就此示例来说，正确的语法应该是 make_pair(1, 2)

利用 make_pair 帮助程序函数，还可以实现向需要一个配对作为输入参数的函数传递两个值。

示例

有关如何使用帮助程序函数 make_pair 声明和初始化对的示例，请参阅 pair结构。

`move`

无条件将其自变量强制转换为右值引用，从而表示其可以移动（如果其类型支持移动）。

template <class Type>
    constexpr typename remove_reference<Type>::type&& move(Type&& Arg) noexcept;

参数

Type
一种从 Arg 中传递的参数类型推导出的类型（与引用折叠规则一起）。

Arg
要强制转换的自变量。虽然 Arg 的类型看起来指定为右值引用，但 move 也接受左值参数，原因是左值引用可以绑定到右值引用。

返回值

作为右值引用 Arg，无论其类型是否是引用类型。

备注

模板自变量 Type 不应显式指定，而应从 Arg 中传递的值类型进行推导。 Type 的类型将根据引用折叠规则进行进一步调整。

move 不会移动其自变量。相反，通过无条件将其参数（可能是左值）强制转换为右值引用，它使得编译器随后能够移动（而不是复制）在 Arg 中传递的值（如果其类型支持移动）。如果其类型不支持移动，则将进行复制。

如果 Arg 中传递的值为左值（也就是说，它具有名称或可以采用其地址），则它在发生移动时将会失效。在移动 Arg 中传递的值后，请勿按照其名称或地址来引用它。

`move_if_noexcept`

template <class T> constexpr conditional_t< !is_nothrow_move_constructible_v<T> && is_copy_constructible_v<T>, const T&, T&&> move_if_noexcept(T& x) noexcept;

`swap`

交换两个类型或 pair结构对象的元素。

template <class T>
    void swap(T& left, T& right) noexcept(see below );
template <class T, size_t N>
    void swap(T (&left)[N], T (&right)[N]) noexcept(is_nothrow_swappable_v<T>);
template <class T, class U>
    void swap(pair<T, U>& left, pair<T, U>& right);

参数

left
类型或类型 pair 的对象。

right
类型或类型 pair 的对象。

备注

swap 的优势之一在于要存储的对象类型由编译器自动确定，而不必显式指定。使用 swap 时请不要使用显式模板自变量（如 swap<int, int>(1, 2)），因为它很详细，会增加复杂的 rvalue 引用问题，这可能会导致编译失败。

`to_chars`

to_chars_result to_chars(char* first, char* last, see below value, int base = 10);
to_chars_result to_chars(char* first, char* last, float value);
to_chars_result to_chars(char* first, char* last, double value);
to_chars_result to_chars(char* first, char* last, long double value);
to_chars_result to_chars(char* first, char* last, float value, chars_format fmt);
to_chars_result to_chars(char* first, char* last, double value, chars_format fmt);
to_chars_result to_chars(char* first, char* last, long double value, chars_format fmt);
to_chars_result to_chars(char* first, char* last, float value, chars_format fmt, int precision);
to_chars_result to_chars(char* first, char* last, double value, chars_format fmt, int precision);
to_chars_result to_chars(char* first, char* last, long double value, chars_format fmt, int precision);

备注

通过填充范围 [first, last) 将值转换为字符串，其中 [first, last) 需要是有效范围。

通过

`<utility>` 函数

`as_const`

返回值

`declval`

`exchange`

参数

注解

示例

`forward`

参数

返回值

备注

from_chars

`get`

参数

备注

示例

`index_sequence`

`index_sequence_for`

`make_index_sequence`

`make_integer_sequence`

`make_pair`

参数

返回值

备注

示例

`move`

参数

返回值

备注

`move_if_noexcept`

`swap`

参数

备注

`to_chars`

备注

反馈

其他资源

通过

<utility> 函数

as_const

返回值

declval

exchange

参数

注解

示例

forward

参数

返回值

备注

from_chars

get

参数

备注

示例

index_sequence

index_sequence_for

make_index_sequence

make_integer_sequence

make_pair

参数

返回值

备注

示例

move

参数

返回值

备注

move_if_noexcept

swap

参数

备注

to_chars

备注

反馈

其他资源

`<utility>` 函数

`as_const`

`declval`

`exchange`

`forward`

`get`

`index_sequence`

`index_sequence_for`

`make_index_sequence`

`make_integer_sequence`

`make_pair`

`move`

`move_if_noexcept`

`swap`

`to_chars`