Devo usar o novo recurso 'automático' do C ++ 11, especialmente em loops?

Quais são os prós / contras de usar a autopalavra - chave, especialmente em loops?

for(std::vector<T>::iterator it = x.begin(); it != x.end(); it++ )
{
   it->something();
}

for(std::map<T>::iterator it = x.begin(); it != x.end(); it++ )
{
   it->second->something();
}

for(auto it = x.begin(); it != x.end(); it++ )
{
   it->??
}

Parece que se você não sabe se você tem um iterador para um mapa ou um vector que você não saberia se ao uso firstou secondou apenas diretamente acessar propriedades do objeto, não?

Isso me lembra o debate em C # sobre a utilização da palavra-chave var. A impressão que estou chegando até agora é que, no mundo C ++, as pessoas estão prontas para adotar a autopalavra-chave com menos esforço do que varno mundo C #. Para mim, meu primeiro instinto é que gosto de saber o tipo da variável para saber quais operações posso executar nela.

As motivações em C ++ são mais extremas, pois os tipos podem se tornar muito mais complicados e complexos do que os tipos C # devido à metaprogramação e outras coisas. autoé mais rápido de escrever e ler e mais flexível / sustentável do que um tipo explícito. Quero dizer, você quer começar a digitar

boost::multi_map<NodeType, indexed_by<ordered_unique<identity<NodeType>>, hashed_non_unique<identity<NodeType>, custom_hasher>>::iterator_type<0> it

Esse nem é o tipo completo. Eu perdi alguns argumentos de modelo.

No seu exemplo:

for(auto it = x.begin(); it != x.end(); i++)
{
  it->??
}

tem que haver uma declaração para xvisível. Portanto, o tipo de itdeve ser óbvio. Se o tipo de xnão for óbvio, o método é muito longo ou a classe é muito grande.

Objeção ! Pergunta carregada.

Você pode me explicar por que o terceiro código contém ??, mas o primeiro e o segundo não? Por uma questão de justiça, seu código deve ser o seguinte:

for(std::vector<T>::iterator it = x.begin(); it != x.end(); i++)
{
   it->???
}

for(std::map<T>::iterator it = x.begin(); it != x.end(); i++)
{
   it->second->???
}

Lá. Mesmo problema, mesmo que você não tenha usado auto.

E em todos os casos, a resposta é a mesma: o contexto é importante . Você não pode falar significativamente sobre um pedaço de código isoladamente. Mesmo se você não tivesse usado modelos, mas algum tipo concreto, isso só teria movido o problema para outro lugar, pois o leitor do seu código precisaria saber sobre a declaração desse tipo.

Se o uso autodessas situações tornar seu código ilegível, você deve tratá-lo como um sinal de aviso de que há algo errado com seu design de código. Obviamente, há casos em que detalhes de baixo nível são importantes (como ao lidar com operações de bits ou API herdada), nos quais um tipo explícito pode ajudar na legibilidade. Mas, em geral - não.

Em relação var(desde que você o mencionou explicitamente), também há um vasto consenso na comunidade C # sobre o uso var. Argumentos contra seu uso geralmente são construídos sobre falácias .

PRÓ

Seu código :

for(std::vector<T>::iterator it = x.begin(); it != x.end(); i++)

não será compilado, devido ao nome dependente do modelo.

Esta é a sintaxe correta:

for( typename std::vector<T>::iterator it = x.begin(); it != x.end(); i++)

Agora veja quanto tempo a declaração de tipo é. Isso explica por que a autopalavra - chave foi introduzida. Este :

for( auto it = x.begin(); it != x.end(); i++)

é mais conciso. Então, este é um profissional.

VIGARISTA

Você tem que ter um pouco de cuidado. Com a palavra-chave auto, você obtém o tipo que declarou.

Por exemplo :

std::vector< int > v{ 1, 2, 3, 4 };
for ( auto it : v )
{
  ++ it;   // ops modifying copies of vector's elements
}

vs

std::vector< int > v{ 1, 2, 3, 4 };
for ( auto & it : v )   // mind the reference
{
  ++ it;   // ok, vector's elements modified
}

Para concluir: sim, você deveria, mas não o use demais. Algumas pessoas tendem a usá-lo demais e colocam auto em qualquer lugar, como no próximo exemplo:

auto i = 0;

vs

int i = 0;

Sim você deveria! autonão apaga o tipo; mesmo se você "não souber" o que x.begin()é, o compilador saberá e relatará um erro se você tentar usar o tipo incorretamente. Além disso, não é incomum emular mapcom a vector<pair<Key,Value>>, portanto, o código usado autofuncionará para as duas representações do dicionário.

Sim, você deve usar autocomo regra padrão. Possui vantagens brutas sobre a especificação explícita do tipo:

• Isso não faz você digitar coisas das quais o compilador já está ciente.
• Faz com que o tipo de variáveis ​​"acompanhe" qualquer alteração nos tipos de valor de retorno.
• Isso evita a introdução silenciosa de conversões implícitas e fatias na inicialização de variáveis ​​locais.
• Isso elimina a necessidade de alguns cálculos de tipo explícito nos modelos.
• Isso elimina a necessidade de nomear tipos de retorno com nomes longos. (aqueles que você copia e cola dos diagnósticos do compilador)

É aqui que você tem uma escolha. Também há casos em que você não tem escolha:

• Permite a declaração de variáveis ​​de tipos indizíveis, como o tipo de uma lambda.

Desde que você saiba exatamente o que autofaz, não há desvantagens.