auto
(C++)
Deduz o tipo de uma variável declarada da expressão de inicialização.
Observação
O padrão do C++ define um significado original e um significado revisado para essa palavra-chave. Antes do Visual Studio 2010, a palavra-chave auto
declara uma variável na classe de armazenamento automatic, ou seja, uma variável que tem tempo de vida local. A partir do Visual Studio 2010, a palavra-chave auto
declara uma variável cujo tipo é deduzido da expressão de inicialização na declaração. A opção de compilador /Zc:auto[-]
controla o significado da palavra-chave auto
.
Sintaxe
auto
declaratorinitializer;
[](auto
param1, auto
param2) {};
Comentários
A palavra-chave auto
direciona o compilador para usar a expressão de inicialização de uma variável declarada ou um parâmetro de expressão lambda para deduzir o tipo.
Recomendamos que você use a palavra-chave auto
para a maioria das situações, a menos que você realmente deseje uma conversão, pois ela fornece estes benefícios:
Robustez: se o tipo da expressão for alterado, inclusive quando um tipo de retorno de função for alterado, ele simplesmente funcionará.
Desempenho: você tem a garantia de que não há conversão.
Usabilidade: você não precisa se preocupar com dificuldades e erros de ortografia do nome do tipo.
Efficiência: a codificação pode ser mais eficiente.
Casos de conversão nos quais você pode não querer usar auto
:
Você quer um tipo específico e nada mais vai fazer.
Em tipos auxiliares de modelo de expressão — por exemplo,
(valarray+valarray)
.
Para usar a palavra-chave auto
, use-a em vez de um tipo para declarar uma variável e especifique uma expressão de inicialização. Além disso, você pode alterar a palavra-chave auto
usando especificadores e declaradores como const
, volatile
, ponteiro (*
), referência (&
) e referência rvalue (&&
). O compilador avalia a expressão e de inicialização e usa essas informações para deduzir o tipo da variável.
A expressão auto
de inicialização pode tomar várias formas:
- Sintaxe de inicialização universal, como
auto a { 42 };
. - Sintaxe de atribuição, como
auto b = 0;
. - Sintaxe de atribuição universal, que combina os dois formulários anteriores, como
auto c = { 3.14159 };
. - Inicialização direta ou sintaxe no estilo construtor, como
auto d( 1.41421f );
.
Para obter mais informações, consulte Inicializadores e exemplos de código mais adiante neste documento.
Quando auto
é usado para declarar o parâmetro loop em uma instrução for
baseada em intervalo, ele usa uma sintaxe de inicialização diferente, por exemplo, for (auto& i : iterable) do_action(i);
. Para obter mais informações, consulte Instrução for
baseada em intervalo (C++).
A auto
palavra-chave é um espaço reservado para um tipo, mas não é em si um tipo. Portanto, a auto
palavra-chave não pode ser usada em casts ou operadores como sizeof
e (para C++/CLI) typeid
.
Utilidade
A palavra-chave auto
é uma maneira simples de declarar uma variável que tenha um tipo complicado. Por exemplo, você pode usar auto
para declarar uma variável onde a expressão de inicialização envolve modelos, ponteiros para as funções ou ponteiros para os membros.
Você também pode usar auto
para declarar e inicializar uma variável em uma expressão lambda. Você não pode declarar o tipo da variável você mesmo pois o tipo de uma expressão lambda é conhecido apenas pelo compilador. Para obter mais informações, confira Exemplos de expressões lambda.
Rastreamento de tipos de retorno
Você pode usar auto
com o especificador de tipo decltype
para ajudar a escrever bibliotecas do modelo. Use auto
e decltype
declare um modelo de função cujo tipo de retorno depende dos tipos de seus argumentos de modelo. Ou, use auto
e decltype
declare um modelo de função que encapsula uma chamada para outra função e, em seguida, retorna qualquer que seja o tipo de retorno dessa outra função. Para obter mais informações, consulte decltype
.
Referências e qualificadores CV
Usando auto
referências de drops, const
qualificadores e volatile
qualificadores. Considere o seguinte exemplo:
// cl.exe /analyze /EHsc /W4
#include <iostream>
using namespace std;
int main( )
{
int count = 10;
int& countRef = count;
auto myAuto = countRef;
countRef = 11;
cout << count << " ";
myAuto = 12;
cout << count << endl;
}
No exemplo anterior, myAuto é um int
, não uma int
referência, então a saída é 11 11
, não como seria o caso se o qualificador de referência não 11 12
tivesse sido descartado por auto
.
Dedução de tipo com inicializadores preparados (C++14)
O exemplo de código a seguir mostra como inicializar uma variável auto
usando chaves. Observe a diferença entre B e C e entre A e E.
#include <initializer_list>
int main()
{
// std::initializer_list<int>
auto A = { 1, 2 };
// std::initializer_list<int>
auto B = { 3 };
// int
auto C{ 4 };
// C3535: cannot deduce type for 'auto' from initializer list'
auto D = { 5, 6.7 };
// C3518 in a direct-list-initialization context the type for 'auto'
// can only be deduced from a single initializer expression
auto E{ 8, 9 };
return 0;
}
Restrições e mensagens de erro
A tabela a seguir lista as limitações no uso da palavra-chave auto
e a mensagem de erro de diagnóstico correspondente, emitida pelo compilador.
Número do erro | Descrição |
---|---|
C3530 | A auto palavra-chave não pode ser combinada com nenhum outro especificador de tipo. |
C3531 | Um símbolo que é declarado com a palavra-chave auto deve ter um inicializador. |
C3532 | Você usou incorretamente a palavra-chave auto para declarar um tipo. Por exemplo, você declarou um tipo de retorno do método ou matriz. |
C3533, C3539 | Um parâmetro ou argumento de modelo não pode ser declarado com a auto palavra-chave. |
C3535 | Um método ou parâmetro de modelo não pode ser declarado com a auto palavra-chave. |
C3536 | Um símbolo não pode ser usado antes de ser inicializado. Na prática, isso significa que uma variável não pode ser usada para se inicializar. |
C3537 | Não é possível converter para um tipo declarado com a auto palavra-chave. |
C3538 | Todos os símbolos em uma lista de declaradores que são declarados com a palavra-chave auto devem ser resolvidos para o mesmo tipo. Para obter mais informações, confira Declarações e Definições. |
C3540, C3541 | Os operadores sizeof e typeid não podem ser aplicados a um símbolo declarado com a auto palavra-chave. |
Exemplos
Estes fragmentos de código ilustram alguns modos de uso da palavra-chave auto
.
As declarações a seguir são equivalentes. Na primeira instrução, a variável j
é declarada como tipo int
. Na segunda instrução, a variável k
é deduzida como sendo do tipo int
pois a expressão de inicialização (0) é um inteiro.
int j = 0; // Variable j is explicitly type int.
auto k = 0; // Variable k is implicitly type int because 0 is an integer.
As seguintes declarações são equivalentes, mas a segunda declaração é mais simples do que a primeira. Um dos motivos mais convincentes para o uso da palavra-chave auto
é a simplicidade.
map<int,list<string>>::iterator i = m.begin();
auto i = m.begin();
O fragmento de código a seguir declara o tipo de variável iter
e elem
quando os loops de for
e de for
do intervalo são iniciados.
// cl /EHsc /nologo /W4
#include <deque>
using namespace std;
int main()
{
deque<double> dqDoubleData(10, 0.1);
for (auto iter = dqDoubleData.begin(); iter != dqDoubleData.end(); ++iter)
{ /* ... */ }
// prefer range-for loops with the following information in mind
// (this applies to any range-for with auto, not just deque)
for (auto elem : dqDoubleData) // COPIES elements, not much better than the previous examples
{ /* ... */ }
for (auto& elem : dqDoubleData) // observes and/or modifies elements IN-PLACE
{ /* ... */ }
for (const auto& elem : dqDoubleData) // observes elements IN-PLACE
{ /* ... */ }
}
O fragmento de código a seguir usa a declaração do operador new
e um ponteiro para declarar ponteiros.
double x = 12.34;
auto *y = new auto(x), **z = new auto(&x);
O próximo fragmento de código declara vários símbolos em cada instrução de declaração. Observe que todos os símbolos em cada instrução são resolvidos para o mesmo tipo.
auto x = 1, *y = &x, **z = &y; // Resolves to int.
auto a(2.01), *b (&a); // Resolves to double.
auto c = 'a', *d(&c); // Resolves to char.
auto m = 1, &n = m; // Resolves to int.
Esse fragmento de código usa o operador condicional (?:
) para declarar a variável x
como um inteiro com o valor de 200:
int v1 = 100, v2 = 200;
auto x = v1 > v2 ? v1 : v2;
O fragmento de código a seguir inicializa a variável x
para o tipo int
, variável y
para uma referência para um tipo const int
, e variável fp
para um ponteiro para uma função que retorna o tipo int
.
int f(int x) { return x; }
int main()
{
auto x = f(0);
const auto& y = f(1);
int (*p)(int x);
p = f;
auto fp = p;
//...
}
Confira também
Palavras-chave
/Zc:auto
(Deduzir tipo de variável)
Operador sizeof
typeid
operator new
Declarações e definições
Exemplos de expressões lambda
Inicializadores
decltype
Comentários
https://aka.ms/ContentUserFeedback.
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:Submeter e ver comentários