`<utility>` -Funktionen

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

Rückgabewert

Gibt T zurück.

`declval`

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

`exchange`

(C++14) Weist einem Objekt einen neuen Wert zu und gibt seinen alten Wert zurück.

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

Parameter

val
Das Objekt, das den Wert von new_val.

new_val
Das Objekt, dessen Wert kopiert oder verschoben valwird.

Hinweise

Vermeiden Sie bei komplexen Typen das Kopieren des alten Werts, exchange wenn ein Verschiebungskonstruktor verfügbar ist, das Kopieren des neuen Werts, wenn es sich um ein temporäres Objekt handelt oder verschoben wird, und akzeptiert jeden Typ als neuen Wert unter Verwendung eines verfügbaren Konvertierungszuweisungsoperators. Die Austauschfunktion unterscheidet sich davon std::swap , dass das linke Argument nicht in das rechte Argument verschoben oder kopiert wird.

Beispiel

Das folgende Beispiel veranschaulicht die Verwendung von exchange. In der Praxis eignet sich exchange am besten für große Objekte, die aufwendig zu kopieren sind:

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

Wandelt bedingt sein Argument in einen rvalue-Verweis um, wenn das Argument ein rvalue-Wert oder ein rvalue-Verweis ist. Dadurch wird die rvalue-Funktion eines Arguments auf die Weiterleitungsfunktion zur Unterstützung einer perfekten Weiterleitung zurückgesetzt.

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

Parameter

Type
Der Typ des Werts, der an Arg übergeben wurde. Dieser kann sich vom Typ Arg unterscheiden. In der Regel bestimmt durch ein Vorlagenargument der Weiterleitungsfunktion.

Arg
Das umzuwandelnde Argument.

Rückgabewert

Gibt einen rvalue-Verweis auf Arg zurück, wenn der Wert, der an Arg übergeben wurde, ursprünglich ein rvalue-Wert oder ein Verweis auf einen rvalue-Wert war; gibt andernfalls Arg zurück, ohne den Typ zu ändern.

Hinweise

Sie müssen ein explizites Vorlagenargument angeben, um forward aufzurufen.

forward leitet das Argument nicht weiter. Stattdessen ermöglicht forward dem Compiler durch bedingte Umwandlung des Arguments in einen rvalue-Verweis, wenn es ursprünglich ein rvalue-Wert oder ein rvalue-Verweis war, eine Überladungsauflösung mit Kenntnis des ursprünglichen Typs des weitergeleiteten Arguments auszuführen. Der scheinbare Typ eines Arguments für eine Weiterleitungsfunktion kann sich von seinem ursprünglichen Typ unterscheiden, z. B. wenn ein Wert als Argument für eine Funktion verwendet wird und an einen Parameternamen gebunden ist; wenn ein Name verwendet wird, wird er als "lvalue" bezeichnet, wobei der Wert tatsächlich als Wert vorhanden ist. forward Stellt die Rvalue-ness des Arguments wieder her.

Die Wiederherstellung der Werte der ursprünglichen Werte eines Arguments zur Überladungsauflösung wird als perfekte Weiterleitung bezeichnet. Mit der perfekten Weiterleitung wird eine Vorlagenfunktion aktiviert, um ein Argument eines Referenztyps zu akzeptieren und die rvalue-Funktion wiederherzustellen, falls es für eine korrekte Überladungsauflösung erforderlich ist. Mithilfe der perfekten Weiterleitung können Sie die Verschiebesemantik für rvalues beibehalten und brauchen keine Überladungen für Funktionen bereitzustellen, die sich nur durch den Referenztyp ihrer Argumente unterscheiden.

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`

Ruft ein Element aus einem pair -Objekt über den Index oder den Typ ab.

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

Parameter

Index
Der 0-basierte Index des ausgewählten Elements.

T1
Der Typ des ersten Paarelements.

T2
Der Typ des zweiten Paarelements.

pr
Das Paar, für das die Auswahl durchgeführt werden soll.

Hinweise

Die Vorlagenfunktionen geben jeweils einen Verweis auf ein Element des pair -Arguments zurück.

Wenn für die indizierten Überladungen der Wert von Index „0“ lautet, geben die Funktionen pr.first zurück, und wenn der Wert von Index „1“ lautet, geben die Funktionen pr.secondzurück. Der Typ RI ist der Typ des zurückgegebenen Elements.

Für die Überladungen, die keinen Parameter besitzen Index , wird das zurückzugebende Element vom Typargument abgeleitet. Das Aufrufen get<T>(Tuple) erzeugt einen Compilerfehler, wenn pr mehr oder weniger als ein Element vom Typ Tenthält.

Beispiel

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

Eine Vorlagenfunktion, die Sie verwenden können, um Objekte vom Typ pair zu erstellen, wobei die Komponententypen automatisch auf Grundlage der Datentypen ausgewählt werden, die als Parameter übergeben werden.

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

Parameter

Val1
Ein Wert, der das erste Element aus pair initialisiert.

Val2
Ein Wert, der das zweite Element aus pair initialisiert.

Rückgabewert

Das pair-Objekt, das erstellt wird: pairT<,U>(Val1, ). Val2

Hinweise

make_pair konvertiert das Objekt vom Typ reference_wrapper "Class " in Verweistypen und konvertiert verfallende Arrays und Funktionen in Zeiger.

im zurückgegebenen pair-Objekt wird T wie folgt bestimmt:

Wenn der Eingabetyp Treference_wrapper<X> ist, lautet der zurückgegebene Typ TX&.
Andernfalls ist der zurückgegebene Typ Tdecay<T>::type. Wenn decay "Class " nicht unterstützt wird, entspricht der zurückgegebene Typ T dem Eingabetyp T.

Der zurückgegebene Typ U wird auf ähnliche Weise anhand des Eingabetyps U bestimmt.

Ein Vorteil make_pair besteht darin, dass die zu speichernden Objekttypen automatisch vom Compiler bestimmt werden und nicht explizit angegeben werden müssen. Verwenden Sie keine expliziten Vorlagenargumente, z make_pair<int, int>(1, 2) . B. wenn Sie diese verwenden make_pair , da sie ausführlich ist, und fügen Sie komplexe Referenzprobleme hinzu, die zu Kompilierungsfehlern führen können. Die korrekte Syntax für dieses Beispiel wäre make_pair(1, 2).

Die make_pair-Hilfsfunktion ermöglicht außerdem, zwei Werte an eine Funktion zu übergeben, die ein Paar als Eingabeparameter erfordert.

Beispiel

Ein Beispiel zur Verwendung der Hilfsfunktion make_pair zum Deklarieren und Initialisieren eines Paars finden Sie unter pair Struktur.

`move`

Wandelt unbedingt das Argument in einen rvalue-Verweis um und signalisiert dadurch, dass es verschoben werden kann, wenn das Verschieben für den zugehörigen Typ aktiviert ist.

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

Parameter

Type
Ein Typ, der von dem Typ des Arguments abgeleitet wurde, das in Arg zusammen mit den Verweisreduzierungsregeln übergeben wurde.

Arg
Das umzuwandelnde Argument. Obwohl der Typ Arg scheinbar als rvalue-Verweis angegeben ist, akzeptiert move auch lvalue-Argumente, da lavalue-Verweise an rvalue-Verweise gebunden werden können.

Rückgabewert

Arg als rvalue-Verweis, unabhängig davon, ob sein Typ ein Verweistyp ist.

Hinweise

Das Vorlagenargument Type soll nicht explizit angegeben werden, sondern vom Typ des übergebenen ArgWerts abgeleitet werden. Der Typ von Type wird den Verweisreduzierungsregeln entsprechend angepasst.

move das Argument wird nicht verschoben. Durch unbedingtes Umwandeln des zugehörigen Arguments, bei dem es sich um ein lvalue-Objekt handeln kann, in einen rvalue-Verweis wird der Compiler stattdessen in die Lage versetzt, den in Arg übergebenen Wert zu verschieben, statt zu kopieren, wenn das Verschieben für den entsprechende Typ aktiviert ist. Wenn der Typ nicht move-enabled ist, wird er stattdessen kopiert.

Wenn der in Arg übergebene Wert ein lvalue ist – d. h., er besitzt einen Namen oder seine Adresse kann akzeptiert werden – wird er ungültig, wenn die Verschiebung erfolgt. Verweisen Sie nicht auf den Wert, der nach dem Verschieben durch den Namen oder die Adresse übergeben Arg wird.

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

Tauscht die Elemente von zwei Typ- oder pair Strukturobjekten aus.

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

Parameter

left
Ein Objekt vom Typ oder Typ pair.

right
Ein Objekt vom Typ oder Typ pair.

Hinweise

Ein Vorteil swap besteht darin, dass die zu speichernden Objekttypen automatisch vom Compiler bestimmt werden und nicht explizit angegeben werden müssen. Verwenden Sie keine expliziten Vorlagenargumente, z swap<int, int>(1, 2) . B. wenn Sie diese verwenden swap , da sie ausführlich ist, und fügen Sie komplexe Referenzprobleme hinzu, die zu Kompilierungsfehlern führen können.

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

Hinweise

Wandelt den Wert in eine Zeichenfolge um, indem er den Bereich [first, last)ausfüllt, wobei [first, last) ein gültiger Bereich erforderlich ist.

Freigeben über

`<utility>` -Funktionen

`as_const`

Rückgabewert

`declval`

`exchange`

Parameter

Hinweise

Beispiel

`forward`

Parameter

Rückgabewert

Hinweise

from_chars

`get`

Parameter

Hinweise

Beispiel

`index_sequence`

`index_sequence_for`

`make_index_sequence`

`make_integer_sequence`

`make_pair`

Parameter

Rückgabewert

Hinweise

Beispiel

`move`

Parameter

Rückgabewert

Hinweise

`move_if_noexcept`

`swap`

Parameter

Hinweise

`to_chars`

Hinweise

Feedback

Zusätzliche Ressourcen

Freigeben über

<utility> -Funktionen

as_const

Rückgabewert

declval

exchange

Parameter

Hinweise

Beispiel

forward

Parameter

Rückgabewert

Hinweise

from_chars

get

Parameter

Hinweise

Beispiel

index_sequence

index_sequence_for

make_index_sequence

make_integer_sequence

make_pair

Parameter

Rückgabewert

Hinweise

Beispiel

move

Parameter

Rückgabewert

Hinweise

move_if_noexcept

swap

Parameter

Hinweise

to_chars

Hinweise

Feedback

Zusätzliche Ressourcen

`<utility>` -Funktionen

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