Tipo auto vs concreto al iterar sobre vector?

Question

El libro que estoy leyendo ofertas este ejemplo cuando se repite durante un v Supongamos vector

for (auto &e: v) { 
    cout << e << endl; 
} 

está declarada como vector<int> v, en otras palabras, sabemos que el tipo de elementos dentro de esta colección es int.

¿Está usando auto de alguna manera mejor o mejor?

for (int &e: v) { 
    cout << e << endl; 
} 

¿Por qué?

Answer 1

Sí. auto es preferido. Porque si cambia la declaración de v de:

std::vector<int> v; //before 

a esto:

std::vector<float> v; //after 

Si utiliza int & en el for, entonces usted tiene que cambiar eso también. ¡Pero con auto, no hay necesidad de cambiar!

En mi opinión, trabajar con auto es más o menos como programming to interface. Así que si usted hace una operación += en el circuito, y realmente no importa el tipo de la variable de bucle e siempre y cuando el tipo de operación es compatible con +=, a continuación, auto es la solución:

for(auto & e : v) 
{ 
     e += 2; 
} 

En este Por ejemplo, todo lo que le importa es que el tipo de e es compatible con += con int en el lado derecho. Funcionará incluso para los tipos definidos por el usuario, que ha definido operator+=(int), o operator+=(T) donde T es un tipo que admite la conversión implícita de int.Es como si usted está programando para la interfaz:

std::vector<Animal*> animals; 
animals.push_back(new Dog()); 
animals.push_back(new Cat()); 
animals.push_back(new Horse()); 

for(size_t i = 0 ; i < animals.size(); ++i) 
{ 
     animals[i]->eat(food); //program to interface 
} 

Por supuesto, le gustaría escribir este bucle como:

for(Animal * animal : animals) 
{ 
     animal->eat(food); //still program to interface 
} 

O simplemente esto:

for(auto animal : animals) 
{ 
     animal->eat(food); //still program to interface 
} 

que es todavía programming to interface.

Pero al mismo tiempo, vale la pena señalar el punto en el comentario de @ David.

Answer 2

En su primer ejemplo, tiene menos dependencia de lo que son los elementos del vector.

Supongamos que, en un mes, necesita que su vector almacene enteros más grandes, por lo que tendrá que usar un tipo std::vector<int64_t>, u otro tipo más amplio. Ahora todos del código que itera sobre ese vector no son válidos. Vas a tener que modificar cada uno:

for (int &e: v) {} 

Para una:

for (int64_t &e: v) {} 

Es por eso que es mejor dejar que auto deducir el tipo interno. De esta forma, puede modificar el tipo almacenado en su vector para otro compatible y todo su código seguirá funcionando.