Funções <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;
Valor de Devolução
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, evita copiar o valor antigo quando um construtor de movimentação está disponível, exchange evita copiar o novo valor se ele 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 Devolução
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 Devolução
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
Tforreference_wrapper<X>, o tipoTretornado seráX&.Caso contrário, o tipo
Tretornado serádecay<T>::type. SedecayClasse não tiver suporte, o tipo retornadoTé igual ao tipo de entradaT.
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 Devolução
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.
Comentários
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja: https://aka.ms/ContentUserFeedback.
Submeter e ver comentários