Compartilhar via

Funções <utility>

  • Artigo

as_const

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

Valor de retorno

Retorna T.

declval

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

exchange

(C++14) Atribui um novo valor a um objeto e retorna seu antigo valor.

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

Parâmetros

val
O objeto que receberá o valor de new_val.

new_val
O objeto cujo valor é copiado ou movido para val.

Comentários

Para tipos complexos, exchange evita copiar o valor antigo quando um construtor de movimentação está disponível, evita copiar o novo valor se for um objeto temporário ou for movido e aceita qualquer tipo como o novo valor, usando qualquer operador de atribuição de conversão disponível. A função exchange é diferente de std::swap em que o argumento à esquerda não é movido ou copiado do argumento à direita.

Exemplo

O exemplo a seguir mostra como usar exchange. No mundo real, exchange é mais útil com objetos grandes de cópia cara:

#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

Converterá condicionalmente seu argumento em uma referência rvalue se o argumento for um rvalue ou referência rvalue. Isso restaura o rvalue-ness de um argumento para a função de encaminhamento como suporte ao encaminhamento perfeito.

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

Parâmetros

Type
O tipo do valor passado em Arg, que pode ser diferente do tipo de Arg. Geralmente determinado por um argumento de modelo da função de encaminhamento.

Arg
O argumento a ser convertido.

Valor de retorno

Retornará uma referência rvalue para Arg se o valor passado em Arg era originalmente um rvalue ou uma referência a um rvalue; caso contrário, retornará Arg sem modificação do seu tipo.

Comentários

Você deve especificar um argumento de modelo explícito para chamar forward.

forward não encaminha seu argumento. Em vez disso, ao converter condicionalmente seu argumento em uma referência rvalue se ele originalmente era um rvalue ou referência rvalue, forward permite que o compilador execute a resolução de sobrecarga com conhecimento do tipo original do argumento encaminhado. O tipo aparente de um argumento para uma função de encaminhamento pode ser diferente do tipo original, por exemplo, quando um rvalue é usado como um argumento para uma função e é associado a um nome de parâmetro; ter um nome que o torna um lvalue, independentemente de o valor realmente existir como um rvalue – forward restaura o rvalue-ness do argumento.

A restauração do rvalue-ness do valor original de um argumento para executar a resolução de sobrecarga é conhecido como encaminhamento perfeito. O encaminhamento perfeito permite que uma função de modelo aceite um argumento do tipo de referência e restaure seu rvalue-ness quando for necessário para resolução de sobrecarga correta. Usando o encaminhamento perfeito, você pode preservar as semânticas de movimento para rvalues, além de evitar ter que fornecer sobrecargas para funções que variam apenas pelo tipo de referência de seus argumentos.

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

Obtém um elemento de um objeto pair, por posição no índice ou por 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;

Parâmetros

Index
O índice baseado em 0 do elemento designado.

T1
O tipo do primeiro elemento do par.

T2
O tipo do segundo elemento do par.

pr
O par do qual selecionar.

Comentários

As funções modelo retornam uma referência a um elemento de seu argumento pair.

Para as sobrecargas indexadas, se o valor de Index for 0, as funções retornarão pr.first e se o valor de Index for 1, as funções retornarão pr.second. O tipo RI é o tipo do elemento retornado.

Para sobrecargas que não têm um parâmetro Index, o elemento a ser retornado é deduzido pelo argumento de tipo. A chamada get<T>(Tuple) produzirá um erro do compilador se pr contiver mais ou menos de um elemento do tipo T.

Exemplo

#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

Uma função de modelo que você pode usar para construir objetos do tipo pair, em que os tipos de componente são automaticamente escolhidos com base nos tipos de dados que são transmitidos como parâmetros.

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

Parâmetros

Val1
O valor que inicializa o primeiro elemento de pair.

Val2
O valor que inicializa o segundo elemento de pair.

Valor de retorno

O objeto par construído: pair<T, U>(Val1, Val2).

Comentários

make_pair converte objeto do tipo reference_wrapper Classe em tipos de referência e converte funções e matrizes decrescentes em ponteiros.

No objeto pair retornado, T é determinado como se segue:

  • Se o tipo de entrada T for reference_wrapper<X>, o tipo T retornado será X&.

  • Caso contrário, o tipo T retornado será decay<T>::type. Se decay Classe não tiver suporte, o tipo retornado T é igual ao tipo de entrada T.

O tipo U retornado é determinado de forma semelhante do tipo de entrada U.

Uma vantagem de make_pair é que os tipos de objetos que estão sendo armazenados são determinados automaticamente pelo compilador e não precisam ser explicitamente especificados. Não use argumentos de modelo explícitos, como make_pair<int, int>(1, 2), ao usar make_pair, pois é desnecessariamente detalhado e adiciona problemas complexos de referência rvalue que podem causar falha de compilação. Para este exemplo, a sintaxe correta seria make_pair(1, 2)

A função auxiliar make_pair também possibilita passar dois valores a uma função que exige um par como um parâmetro de entrada.

Exemplo

Para obter um exemplo de como usar a função auxiliar make_pair para declarar e inicializar um par, consulte pairEstrutura.

move

Converte incondicionalmente seu argumento em uma referência de rvalue e, assim, os sinais que podem ser movidos se seu tipo for habilitado para movimento.

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

Parâmetros

Type
Um tipo deduzido do tipo do argumento passado em Arg, juntamente com as regras de recolhimento de referência.

Arg
O argumento a ser convertido. Embora o tipo de Arg pareça ser especificado como uma referência de rvalue, move também aceita argumentos lvalue, pois as referência de lvalue podem se associar a referências de rvalue.

Valor de retorno

Arg como uma referência de rvalue, seja ou não seu tipo um tipo de referência.

Comentários

O argumento de modelo Type não deve ser especificado explicitamente, mas deve ser deduzido do tipo do valor passado em Arg. O tipo de Type é ainda ajustado de acordo com as regras de recolhimento de referência.

move não move seu argumento. Em vez disso, ao converter incondicionalmente seu argumento (que pode ser um lvalue) em uma referência de rvalue, ele permite que o compilador mova subsequentemente, em vez de copiar, o valor passado em Arg se seu tipo for habilitado para movimento. Se seu tipo não for habilitado para movimento, ele será copiado.

Se o valor passado em Arg for um lvalue, isto é, tiver um nome ou seu endereço puder ser usado, ele será invalidado quando a movimentação ocorrer. Não faça referência ao valor passado em Arg por seu nome ou endereço depois que movido.

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

Troca os elementos de dois tipos ou objetos pair Estrutura.

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

Parâmetros

left
Um objeto do tipo ou tipo pair.

right
Um objeto do tipo ou tipo pair.

Comentários

Uma vantagem de swap é que os tipos de objetos que estão sendo armazenados são determinados automaticamente pelo compilador e não precisam ser explicitamente especificados. Não use argumentos de modelo explícitos, como swap<int, int>(1, 2), ao usar swap, pois é desnecessariamente detalhado e adiciona problemas complexos de referência rvalue que podem causar falha de compilação.

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

Comentários

Converte o valor em uma cadeia de caracteres preenchendo o intervalo [first, last), em que [first, last) deve ser um intervalo válido.