Condividi tramite

<utility> funzioni

  • Articolo

as_const

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

Valore restituito

Restituisce T.

declval

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

exchange

(C++14) Assegna un nuovo valore a un oggetto e restituisce il valore precedente.

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

Parametri

val
Oggetto che riceverà il valore di new_val.

new_val
Oggetto il cui valore viene copiato o spostato in val.

Osservazioni:

Per i tipi complessi, exchange evita di copiare il valore precedente quando è disponibile un costruttore di spostamento, evita di copiare il nuovo valore se si tratta di un oggetto temporaneo o viene spostato e accetta qualsiasi tipo come nuovo valore, usando qualsiasi operatore di assegnazione di conversione disponibile. La funzione di scambio è diversa da in std::swap quanto l'argomento sinistro non viene spostato o copiato nell'argomento destro.

Esempio

Nell'esempio riportato di seguito viene illustrato come usare exchange. Nel mondo reale exchange risulta più utile con oggetti di grandi dimensioni che sono troppo onerosi da copiare:

#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

Esegue il cast in modo condizionale del relativo argomento a un riferimento rvalue se l'argomento è un rvalue o un riferimento rvalue. In questo modo viene ripristinata la caratteristica rvalue di una funzione di inoltro in supporto dell'inoltro perfetto.

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

Parametri

Type
Tipo di valore passato in Arg, che potrebbe essere diverso dal tipo di Arg, in genere determinato da un argomento di modello della funzione di inoltro.

Arg
Argomento di cui eseguire il cast.

Valore restituito

Restituisce un riferimento rvalue a Arg se il valore passato in Arg era in origine un rvalue o un riferimento a un rvalue; in caso contrario, restituisce Arg senza modificarne il tipo.

Osservazioni:

È necessario specificare un argomento di modello esplicito per chiamare forward.

forward non inoltra l'argomento. Al contrario, l'esecuzione del cast in modo condizionale del relativo argomento a un riferimento rvalue se in origine era un rvalue o un riferimento rvalue, forward consente al compilatore di eseguire la risoluzione dell'overload e di conoscere il tipo originale dell'argomento inoltrato. Il tipo apparente di un argomento di una funzione di inoltro potrebbe essere diverso dal tipo originale, ad esempio quando un rvalue viene usato come argomento per una funzione ed è associato a un nome di parametro; avere un nome lo rende un lvalue, con qualsiasi valore esista effettivamente come rvalue, forward ripristina la rvalue-ness dell'argomento.

Il ripristino della rvalue-ness del valore originale di un argomento per eseguire la risoluzione dell'overload è noto come inoltro perfetto. L'inoltro perfetto consente a una funzione di modello di accettare un argomento di un tipo di riferimento e di ripristinare la caratteristica rvalue quando è necessario per una risoluzione corretta dell'overload. Utilizzando l'inoltro perfetto è possibile mantenere la semantica di spostamento relativa agli rvalue ed evitare di fornire gli overload per le funzioni che variano solo in base al tipo di riferimento dei relativi argomenti.

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

Consente di visualizzare un elemento dall'oggetto pair in base alla posizione di indice o in base al tipo.

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

Parametri

Index
Indice in base 0 dell'elemento scelto.

T1
Tipo di elemento della prima coppia.

T2
Tipo di elemento della seconda coppia.

pr
Coppia da selezionare.

Osservazioni:

Le funzioni modello restituiscono un riferimento a un elemento del relativo argomento pair .

Per gli overload indicizzati, se il valore di Index è 0, le funzioni restituiscono pr.first ; se il valore di Index è 1, le funzioni restituiscono pr.second. Il tipo RI è il tipo dell'elemento restituito.

Per gli overload che non dispongono di un Index parametro, l'elemento da restituire viene dedotto dall'argomento di tipo . La chiamata get<T>(Tuple) genererà un errore del compilatore se pr contiene più o meno di un elemento di tipo T.

Esempio

#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

Funzione di modello che è possibile usare per costruire oggetti di tipo pair, in cui i tipi di componenti vengono automaticamente scelti in base ai tipi di dati passati come parametri.

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

Parametri

Val1
Valore che inizializza il primo elemento di pair.

Val2
Valore che inizializza il secondo elemento di pair.

Valore restituito

Oggetto pair costruito: pairT<,U>(Val1, ). Val2

Osservazioni:

make_pair converte l'oggetto di tipo reference_wrapper Class in tipi di riferimento e converte matrici e funzioni in puntatori.

Nell'oggetto restituito pair, T viene determinato come segue:

  • Se il tipo di input T è reference_wrapper<X>, il tipo restituito T è X&.

  • In caso contrario, il tipo restituito T è decay<T>::type. Se decay Class non è supportato, il tipo T restituito corrisponde al tipo di Tinput .

Se il tipo restituito U viene determinato in modo analogo dal tipo di input U.

Uno dei make_pair vantaggi è che i tipi di oggetti archiviati vengono determinati automaticamente dal compilatore e non devono essere specificati in modo esplicito. Non usare argomenti di modello espliciti, ad make_pair<int, int>(1, 2) esempio quando si usa make_pair perché è dettagliato e aggiunge problemi di riferimento rvalue complessi che potrebbero causare errori di compilazione. Per questo esempio, la sintassi corretta sarà make_pair(1, 2).

La funzione helper make_pair consente di passare due valori a una funzione che richiede una coppia come parametro di input.

Esempio

Per un esempio su come usare la funzione make_pair helper per dichiarare e inizializzare una coppia, vedere pair Struttura.

move

Esegue il cast in modo condizionale del relativo argomento a un riferimento rvalue e segnala pertanto che può essere spostato se il relativo tipo è abilitato allo spostamento.

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

Parametri

Type
Tipo dedotto dal tipo dell'argomento passato in Arg, insieme alle regole di compressione dei riferimenti.

Arg
Argomento di cui eseguire il cast. Anche il tipo di Arg sembra essere specificato come riferimento rvalue, move accetta anche argomenti lvalue poiché tali riferimenti possono essere associati ai riferimenti rvalue.

Valore restituito

Arg come riferimento rvalue, indipendentemente dal fatto che il relativo tipo sia un tipo di riferimento.

Osservazioni:

L'argomento Type modello non deve essere specificato in modo esplicito, ma deve essere dedotto dal tipo del valore passato in Arg. Il tipo di Type viene ulteriormente modificato in base alle regole di compressione dei riferimenti.

move non sposta l'argomento. L'esecuzione invece del cast in modo non condizionale del relativo argomento, che potrebbe essere un lvalue, a un riferimento rvalue, consente al compilatore di spostarsi successivamente anziché copiare il valore passato in Arg se il relativo tipo è abilitato allo spostamento. Se il tipo non è abilitato per lo spostamento, viene copiato.

Se il valore passato in Arg è un lvalue, ovvero dispone di un nome o il relativo indirizzo può essere accettato, viene invalidato quando si verifica lo spostamento. Non fare riferimento al valore passato Arg dal nome o dall'indirizzo dopo che è stato spostato.

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

Scambia gli elementi di due tipi o pair oggetti 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);

Parametri

left
Oggetto di tipo o di tipo pair.

right
Oggetto di tipo o di tipo pair.

Osservazioni:

Uno dei swap vantaggi è che i tipi di oggetti archiviati vengono determinati automaticamente dal compilatore e non devono essere specificati in modo esplicito. Non usare argomenti di modello espliciti, ad swap<int, int>(1, 2) esempio quando si usa swap perché è dettagliato e aggiunge problemi di riferimento rvalue complessi che potrebbero causare errori di compilazione.

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

Osservazioni:

Converte il valore in una stringa di caratteri riempiendo l'intervallo [first, last), dove [first, last) deve essere un intervallo valido.