fonctions`<utility>`

Article
10/12/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;

Valeur de retour

Retourne T.

`declval`

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

`exchange`

(C++14) Affecte une nouvelle valeur à un objet et retourne son ancienne valeur.

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

Paramètres

val
Objet qui recevra la valeur de new_val.

new_val
Objet dont la valeur est copiée ou déplacée vers val.

Notes

Pour les types complexes, exchange évite de copier l’ancienne valeur lorsqu’un constructeur de déplacement est disponible, évite de copier la nouvelle valeur s’il s’agit d’un objet temporaire ou est déplacé, et accepte n’importe quel type comme nouvelle valeur, à l’aide d’un opérateur d’affectation de conversion disponible. La fonction d’échange est différente de celle de std::swap l’argument gauche qui n’est pas déplacée ou copiée vers l’argument de droite.

Exemple

L'exemple suivant montre comment utiliser exchange. En réalité, exchange est particulièrement utile avec les objets volumineux qui sont coûteux à copier :

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

Convertit de manière conditionnelle son argument en une référence rvalue, si l’argument est une rvalue ou une référence rvalue. Cette opération restaure la nature rvalue d’un argument pour le transfert parfait.

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

Paramètres

Type
Type de la valeur passée dans Arg, qui peut être différent du type de Arg. Généralement déterminé par un argument template de la fonction de transfert.

Arg
Argument sur lequel effectuer un cast.

Valeur de retour

Retourne une référence rvalue à Arg si la valeur passée dans Arg était à l'origine une rvalue ou une référence rvalue ; sinon, retourne Arg sans modifier son type.

Notes

Vous devez spécifier un argument template explicite pour appeler forward.

forward ne transfère pas son argument. En revanche, en convertissant son argument de manière conditionnelle en une référence rvalue, s'il s'agissait à l'origine d'une rvalue ou d'une référence rvalue, forward permet au compilateur d'effectuer une résolution de surcharge en connaissant le type d'origine de l'argument transféré. Le type apparent d’un argument à une fonction de transfert peut être différent de son type d’origine, par exemple lorsqu’une rvalue est utilisée comme argument pour une fonction et est liée à un nom de paramètre ; avoir un nom le rend lvalue, avec la valeur qui existe réellement en tant que rvalue, forward restaure la rvalue-ness de l’argument.

La restauration de la valeur d’origine d’un argument pour effectuer une résolution de surcharge est appelée transfert parfait. Le transfert parfait permet à une fonction de modèle d’accepter un argument de n’importe quel type référence et de restaurer sa nature rvalue si nécessaire, pour une résolution de surcharge appropriée. Le transfert parfait permet de préserver la sémantique de déplacement des rvalue et évite d’avoir à fournir des surcharges pour les fonctions qui varient uniquement par le type référence de leurs arguments.

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`

Obtient un élément d’un objet pair , par position d’index ou par type.

// 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;

Paramètres

Index
Index de base 0 de l’élément choisi.

T1
Type du premier élément de la paire.

T2
Type du deuxième élément de la paire.

pr
Paire dans laquelle opérer la sélection.

Notes

Chaque fonction de modèle retourne une référence à un élément de son pair argument.

Pour les surcharges indexées, si la valeur de Index est 0, les fonctions retournent pr.first ; si la valeur de Index est 1, les fonctions retournent pr.second. Le type RI est le type de l’élément retourné.

Pour les surcharges qui n’ont pas de Index paramètre, l’élément à retourner est déduit par l’argument de type. L’appel get<T>(Tuple) génère une erreur du compilateur s’il pr contient plus ou moins d’un élément de type T.

Exemple

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

Fonction de modèle que vous pouvez utiliser pour construire des objets de type pair, dont les types de composants sont sélectionnés automatiquement en fonction des types de données qui sont transmis comme paramètres.

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);

Paramètres

Val1
Valeur qui initialise le premier élément de pair.

Val2
Valeur qui initialise le second élément de pair.

Valeur de retour

Objet de paire construit : pairT<,U>(Val1, ). Val2

Notes

make_pairconvertit l’objet de la classe de type reference_wrapper en types de référence et convertit les tableaux et fonctions en pointeurs.

Dans l'objet pair retourné, T est déterminé comme suit :

Si le type d'entrée T a pour valeur reference_wrapper<X>, le type retourné T a pour valeur X&.
Sinon, le type retourné T a pour valeur decay<T>::type. Si decay la classe n’est pas prise en charge, le type T retourné est identique au type Td’entrée.

Le type retourné U est déterminé de façon similaire à partir du type d'entrée U.

L’un des avantages est make_pair que les types d’objets stockés sont déterminés automatiquement par le compilateur et ne doivent pas être spécifiés explicitement. N’utilisez pas d’arguments de modèle explicites tels que make_pair<int, int>(1, 2) lorsque vous utilisez make_pair , car il est détaillé et ajoute des problèmes de référence rvalue complexes susceptibles d’entraîner un échec de compilation. Pour cet exemple, la syntaxe correcte serait make_pair(1, 2).

La fonction d'assistance make_pair permet également de transmettre deux valeurs à une fonction qui requiert une paire en tant que paramètre d'entrée.

Exemple

Pour obtenir un exemple sur l’utilisation de la fonction make_pair d’assistance pour déclarer et initialiser une paire, consultez pair Structure.

`move`

Effectue un cast non conditionnel de son argument en une référence rvalue, et signale par là-même qu’elle peut être déplacée si son type prend en charge le mouvement.

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

Paramètres

Type
Type déduit du type de l'argument transmis dans Arg, avec les règles de réduction de référence.

Arg
Argument sur lequel effectuer un cast. Bien que le type de Arg semble être spécifié en tant que référence rvalue, move accepte également les arguments lvalue, car les références lvalue peuvent être liées aux références rvalue.

Valeur de retour

Arg en tant que référence rvalue, que son type soit un type référence ou non.

Notes

L’argument Type de modèle n’est pas destiné à être spécifié explicitement, mais à déduire du type de la valeur passée Arg. Le type de Type est ajusté plus en détail en fonction des règles de réduction de référence.

move ne déplace pas son argument. Au lieu de cela, en effectuant un cast non conditionnel de son argument (qui peut être une lvalue) en une référence rvalue, elle permet au compilateur de déplacer ultérieurement, plutôt que de copier, la valeur transmise dans Arg si son type prend en charge le mouvement. Si son type n’est pas activé pour le déplacement, il est copié à la place.

Si la valeur transmise dans Arg est une lvalue (autrement dit, si elle a un nom ou que son adresse peut être prise), elle est invalidée lorsque le déplacement se produit. Ne faites pas référence à la valeur transmise Arg par son nom ou son adresse après son déplacement.

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

Échange les éléments de deux types ou pair objets Structure .

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);

Paramètres

left
Objet de type ou de type pair.

right
Objet de type ou de type pair.

Notes

L’un des avantages est swap que les types d’objets stockés sont déterminés automatiquement par le compilateur et ne doivent pas être spécifiés explicitement. N’utilisez pas d’arguments de modèle explicites tels que swap<int, int>(1, 2) lorsque vous utilisez swap , car il est détaillé et ajoute des problèmes de référence rvalue complexes susceptibles d’entraîner un échec de compilation.

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

Notes

Convertit la valeur en chaîne de caractères en remplissant la plage [first, last), où il [first, last) est nécessaire d’être une plage valide.

Partager via

fonctions`<utility>`

`as_const`

Valeur de retour

`declval`

`exchange`

Paramètres

Notes

Exemple

`forward`

Paramètres

Valeur de retour

Notes

from_chars

`get`

Paramètres

Notes

Exemple

`index_sequence`

`index_sequence_for`

`make_index_sequence`

`make_integer_sequence`

`make_pair`

Paramètres

Valeur de retour

Notes

Exemple

`move`

Paramètres

Valeur de retour

Notes

`move_if_noexcept`

`swap`

Paramètres

Notes

`to_chars`

Notes

Commentaires

Ressources supplémentaires

Partager via

fonctions<utility>

as_const

Valeur de retour

declval

exchange

Paramètres

Notes

Exemple

forward

Paramètres

Valeur de retour

Notes

from_chars

get

Paramètres

Notes

Exemple

index_sequence

index_sequence_for

make_index_sequence

make_integer_sequence

make_pair

Paramètres

Valeur de retour

Notes

Exemple

move

Paramètres

Valeur de retour

Notes

move_if_noexcept

swap

Paramètres

Notes

to_chars

Notes

Commentaires

Ressources supplémentaires

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