`<utility>` 関数

`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 が関数の引数として使用され、パラメーター名にバインドされている場合、名前を付けると、どの値が実際に rvalue として存在する場合でも lvalue になります。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
1 番目の pair 要素の型。

T2
2 番目の pair 要素の型。

pr
選択する pair。

解説

各テンプレート関数は、 pair 引数の要素への参照を返します。

インデックスを使用したオーバーロードでは、関数は、 Index の値が 0 の場合は pr.first を返し、 Index の値が 1 の場合は pr.secondを返します。型 RI は、返される要素の型です。

Index パラメーターがないオーバーロードでは、返される要素は型の引数によって推測されます。 pr に含まれる型 T の要素の数が 1 より多いか少ない場合、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 の 2 番目の要素を初期化する値。

戻り値

作成されたペアオブジェクト: 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 の利点の 1 つは、格納されるオブジェクトの型がコンパイラによって自動的に決定され、明示的に指定する必要がないことです。 make_pair を使用する場合は、make_pair<int, int>(1, 2) などの明示的なテンプレート引数を使用しないでください。詳細になって、複雑な rvalue 参照の問題が追加され、コンパイルエラーの原因となる可能性があるためです。この例の場合、正しい構文は make_pair(1, 2) です。

make_pair ヘルパー関数は、入力パラメーターとしてペアを必要とする関数に 2 個の値を渡すこともできます。

例

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`

2 つの型または 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 の利点の 1 つは、格納されるオブジェクトの型がコンパイラによって自動的に決定され、明示的に指定する必要がないことです。 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) は有効な範囲であることが必要です。

フィードバック

このページはお役に立ちましたか?

Last updated on 2025-11-07

次の方法で共有

<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`