Existe uma desvantagem em declarar variáveis ​​com auto em C ++?

Parece que autofoi um recurso bastante significativo a ser adicionado no C ++ 11 que parece seguir muitas das linguagens mais recentes. Como em uma linguagem como Python, não vi nenhuma declaração explícita de variável (não tenho certeza se é possível usar os padrões Python).

Existe uma desvantagem em usar autopara declarar variáveis ​​em vez de declará-las explicitamente?

Você só perguntou sobre desvantagens, então estou destacando algumas delas. Quando usado bem, autotem várias vantagens também. As desvantagens resultam da facilidade de abuso e do aumento do potencial do código para se comportar de maneira não intencional.

A principal desvantagem é que, ao usar auto, você não conhece necessariamente o tipo de objeto que está sendo criado. Há também ocasiões em que o programador pode esperar que o compilador deduza um tipo, mas o compilador deduz com firmeza outro.

Dada uma declaração como

auto result = CallSomeFunction(x,y,z);

você não tem necessariamente conhecimento de que tipo resulté. Pode ser um int. Pode ser um ponteiro. Pode ser outra coisa. Todos esses suportam operações diferentes. Você também pode alterar drasticamente o código com uma pequena alteração, como

auto result = CallSomeFunction(a,y,z);

porque, dependendo das sobrecargas existentes para CallSomeFunction()o tipo de resultado, pode ser completamente diferente - e, portanto, o código subsequente pode se comportar de maneira totalmente diferente do pretendido. Você pode disparar mensagens de erro repentinamente em códigos posteriores (por exemplo, subseqüentemente tentando desreferenciar um int, tentando mudar algo que está agora const). A mudança mais sinistra é onde sua mudança passa pelo compilador, mas o código subsequente se comporta de maneiras diferentes e desconhecidas - possivelmente com erros.

Não ter conhecimento explícito do tipo de algumas variáveis, portanto, torna mais difícil justificar rigorosamente uma afirmação de que o código funciona como pretendido. Isso significa mais esforço para justificar reivindicações de "adequação à finalidade" em domínios de alta criticidade (por exemplo, crítica à segurança ou crítica à missão).

A outra desvantagem mais comum é a tentação de um programador usar autocomo um instrumento contundente para forçar a compilação do código, em vez de pensar no que o código está fazendo e trabalhar para corrigi-lo.

Isso não é autoexatamente uma desvantagem de princípios, mas em termos práticos parece ser um problema para alguns. Basicamente, algumas pessoas: a) tratam autocomo salvadores de tipos e desligam o cérebro ao usá-lo; ou b) esquecem que autosempre deduz aos tipos de valor. Isso faz com que as pessoas façam coisas assim:

auto x = my_obj.method_that_returns_reference();

Opa, nós apenas copiamos profundamente algum objeto. Geralmente, é um bug ou uma falha no desempenho. Então, você pode mudar para o outro lado:

const auto& stuff = *func_that_returns_unique_ptr();

Agora você recebe uma referência pendente. Esses problemas não são causados ​​por autonada, então não os considero argumentos legítimos contra ele. Mas parece que autoessas questões são mais comuns (por experiência própria), pelas razões que listei no começo.

Penso que, com o tempo, as pessoas se ajustarão e entenderão a divisão do trabalho: autodeduz o tipo subjacente, mas você ainda deseja pensar em referência e constância. Mas está demorando um pouco.

Outras respostas estão mencionando desvantagens como "você realmente não sabe qual é o tipo de variável". Eu diria que isso está amplamente relacionado à convenção de nomes desleixados no código. Se suas interfaces tiverem um nome claro, você não precisará se importar com o tipo exato. Claro, auto result = callSomeFunction(a, b);não diz muito. Mas auto valid = isValid(xmlFile, schema);diz o suficiente para você usar validsem ter que se importar com o seu tipo exato. Afinal, com apenas if (callSomeFunction(a, b)), você também não saberia o tipo. O mesmo com qualquer outro objeto temporário de subexpressão. Portanto, não considero isso uma verdadeira desvantagem auto.

Eu diria que sua principal desvantagem é que, às vezes, o tipo de retorno exato não é o que você deseja trabalhar. De fato, algumas vezes o tipo de retorno real difere do tipo de retorno "lógico" como um detalhe de implementação / otimização. Modelos de expressão são um excelente exemplo. Digamos que temos o seguinte:

SomeType operator* (const Matrix &lhs, const Vector &rhs);

Logicamente, esperamos SomeTypeser Vector, e definitivamente queremos tratá-lo como tal em nosso código. No entanto, é possível que, para fins de otimização, a biblioteca de álgebra que estamos usando implementa modelos de expressão, e o tipo de retorno real seja este:

MultExpression<Matrix, Vector> operator* (const Matrix &lhs, const Vector &rhs);

Agora, o problema é que MultExpression<Matrix, Vector>a vontade em toda a loja de probabilidade de um const Matrix&e const Vector&internamente; espera que seja convertido em a Vectorantes do final de sua expressão completa. Se temos esse código, está tudo bem:

extern Matrix a, b, c;
extern Vector v;

void compute()
{
  Vector res = a * (b * (c * v));
  // do something with res
}

No entanto, se tivéssemos usado autoaqui, poderíamos ter problemas:

void compute()
{
  auto res = a * (b * (c * v));
  // Oops! Now `res` is referring to temporaries (such as (c * v)) which no longer exist
}

Uma das desvantagens é que às vezes você não pode declarar const_iteratorcom auto. Você obterá o iterador comum (não const) neste exemplo de código extraído desta pergunta :

map<string,int> usa;
//...init usa
auto city_it = usa.find("New York");

Isso torna seu código um pouco mais difícil, ou tedioso, de ler. Imagine algo assim:

auto output = doSomethingWithData(variables);

Agora, para descobrir o tipo de saída, você teria que rastrear a assinatura da doSomethingWithDatafunção.

Como esse desenvolvedor, eu odeio auto. Ou melhor, odeio como as pessoas fazem mau uso auto.

Sou da opinião (forte) de que autoé para ajudá-lo a escrever código genérico, não para reduzir a digitação .
C ++ é uma linguagem cujo objetivo é permitir que você escreva um código robusto, não para minimizar o tempo de desenvolvimento.
Isso é bastante óbvio em muitos recursos do C ++, mas, infelizmente, alguns dos mais novos autoreduzem a digitação das pessoas que levam a pensar que devem começar a ficar preguiçosos com a digitação.

Nos autodias anteriores , as pessoas usavam typedefs, o que foi ótimo, porque typedef permitiu ao designer da biblioteca ajudá-lo a descobrir qual deveria ser o tipo de retorno, para que a biblioteca funcionasse conforme o esperado. Quando você usa auto, tira esse controle do designer da classe e, em vez disso, pede ao compilador para descobrir qual deve ser o tipo, o que remove uma das ferramentas C ++ mais poderosas da caixa de ferramentas e corre o risco de quebrar seu código.

Geralmente, se você usar auto, deve ser porque seu código funciona para qualquer tipo razoável , não porque você é preguiçoso demais para anotar o tipo com o qual deve trabalhar. Se você usa autocomo uma ferramenta para ajudar a preguiça, o que acontece é que você acaba introduzindo erros sutis em seu programa, geralmente causados ​​por conversões implícitas que não aconteceram porque você o usou auto.

Infelizmente, esses bugs são difíceis de ilustrar em um pequeno exemplo aqui, porque sua brevidade os torna menos convincentes do que os exemplos reais que surgem em um projeto de usuário - no entanto, eles ocorrem facilmente em códigos pesados ​​de modelo que esperam que certas conversões implícitas ocorram Lugar, colocar.

Se você quiser um exemplo, há um aqui . Uma pequena observação: porém, antes de ser tentado a pular e criticar o código: lembre-se de que muitas bibliotecas conhecidas e maduras foram desenvolvidas em torno de conversões implícitas e existem porque resolvem problemas que podem ser difíceis, se não impossíveis. para resolver o contrário. Tente descobrir uma solução melhor antes de criticá-los.

autonão tem desvantagens em si , e eu advogo que (manualmente) use-o em qualquer lugar do novo código. Ele permite que seu código verifique consistentemente e evite fatias silenciosas. (Se Bderiva de Ae uma função retornando Arepentinamente retorna B, então autose comporta conforme o esperado para armazenar seu valor de retorno)

Embora o código legado anterior ao C ++ 11 possa contar com conversões implícitas induzidas pelo uso de variáveis ​​de tipo explícito. Alterar uma variável de tipo explícito para autopode alterar o comportamento do código , por isso é melhor ter cuidado.

A palavra-chave autosimplesmente deduz o tipo do valor retornado. Portanto, não é equivalente a um objeto Python, por exemplo

# Python
a
a = 10       # OK
a = "10"     # OK
a = ClassA() # OK

// C++
auto a;      // Unable to deduce variable a
auto a = 10; // OK
a = "10";    // Value of const char* can't be assigned to int
a = ClassA{} // Value of ClassA can't be assigned to int
a = 10.0;    // OK, implicit casting warning

Como autoé deduzido durante a compilação, ele não terá nenhuma desvantagem no tempo de execução.

O que ninguém mencionou aqui até agora, mas vale por si só uma resposta, se você me perguntasse.

Como (mesmo que todos devam estar cientes disso C != C++), o código escrito em C pode ser facilmente projetado para fornecer uma base para o código C ++ e, portanto, ser projetado sem muito esforço para ser compatível com C ++, isso pode ser um requisito para o design.

Conheço algumas regras em que algumas construções bem definidas Csão inválidas C++e vice-versa. Mas isso resultaria simplesmente em executáveis ​​quebrados e a cláusula UB conhecida se aplica, que na maioria das vezes é notada por ciclos estranhos que resultam em travamentos ou o que for (ou até pode ficar sem ser detectado, mas isso não importa aqui).

Mas autoé a primeira vez ¹ isso muda!

Imagine que você usou autocomo especificador de classe de armazenamento antes e transfira o código. Nem mesmo necessariamente (dependendo da maneira como foi usado) "quebrou"; na verdade, ele pode alterar silenciosamente o comportamento do programa.

Isso é algo que se deve ter em mente.

¹ _{Pelo menos na primeira vez que estou ciente.}

Uma razão pela qual consigo pensar é que você perde a oportunidade de coagir a classe retornada. Se sua função ou método retornou um longo de 64 bits e você só queria um int não assinado de 32, então você perde a oportunidade de controlá-lo.

Como eu descrevi nesta resposta, auto às vezes pode resultar em situações estranhas que você não pretendia. Você tem que dizer explicitamente auto&para ter um tipo de referência, enquanto apenas autopode criar um tipo de ponteiro. Isso pode resultar em confusão, omitindo todo o especificador, resultando em uma cópia da referência em vez de uma referência real.

Outro exemplo irritante:

for (auto i = 0; i < s.size(); ++i)

gera um aviso ( comparison between signed and unsigned integer expressions [-Wsign-compare]), porque ié um int assinado. Para evitar isso, você precisa escrever, por exemplo,

for (auto i = 0U; i < s.size(); ++i)

ou talvez melhor:

for (auto i = 0ULL; i < s.size(); ++i)

Eu acho que autoé bom quando usado em um contexto localizado, onde o leitor facilmente e obviamente pode deduzir seu tipo, ou bem documentado com um comentário de seu tipo ou um nome que infere o tipo real. Quem não entende como isso funciona pode levá-lo de maneira errada, como usá-lo em vez de templateou similar. Aqui estão alguns casos de uso bons e ruins na minha opinião.

void test (const int & a)
{
    // b is not const
    // b is not a reference

    auto b = a;

    // b type is decided by the compiler based on value of a
    // a is int
}

Bons usos

Iteradores

std::vector<boost::tuple<ClassWithLongName1,std::vector<ClassWithLongName2>,int> v();

..

std::vector<boost::tuple<ClassWithLongName1,std::vector<ClassWithLongName2>,int>::iterator it = v.begin();

// VS

auto vi = v.begin();

Ponteiros de Função

int test (ClassWithLongName1 a, ClassWithLongName2 b, int c)
{
    ..
}

..

int (*fp)(ClassWithLongName1, ClassWithLongName2, int) = test;

// VS

auto *f = test;

Maus usos

Fluxo de dados

auto input = "";

..

auto output = test(input);

Função Assinatura

auto test (auto a, auto b, auto c)
{
    ..
}

Casos triviais

for(auto i = 0; i < 100; i++)
{
    ..
}

Estou surpreso que ninguém tenha mencionado isso, mas suponha que você esteja calculando o fatorial de algo:

#include <iostream>
using namespace std;

int main() {
    auto n = 40;
    auto factorial = 1;

    for(int i = 1; i <=n; ++i)
    {
        factorial *= i;
    }

    cout << "Factorial of " << n << " = " << factorial <<endl;   
    cout << "Size of factorial: " << sizeof(factorial) << endl; 
    return 0;
}

Este código produzirá o seguinte:

Factorial of 40 = 0
Size of factorial: 4

Esse definitivamente não foi o resultado esperado. Isso aconteceu porque autodeduziu o tipo da variável fatorial como intporque foi atribuída 1.