Auto vs konkrete Art beim Iterieren über Vektor?

Question

Das Buch i Angebote Dieses Beispiel liest, wenn über ein

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

Es wäre v vector

Iterieren als vector<int> v erklärt, mit anderen Worten, wissen wir, dass die Art der Elemente in dieser Sammlung int ist.

Wird auto in irgendeiner Weise besser oder vorgezogen?

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

Warum?

Answer 1

Ja. auto ist bevorzugt. Denn wenn Sie die Deklaration von v von ändern:

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

dazu:

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

Wenn Sie int & im for verwenden, dann müssen Sie das auch ändern. Aber mit auto, keine Notwendigkeit zu ändern!

Meiner Meinung nach ist die Arbeit mit mehr oder weniger wie programming to interface. Also, wenn Sie eine Operation += in der Schleife zu tun, und Sie nicht wirklich über die Art der Schleifenvariable e solange die Art += Betrieb unterstützt, dann ist auto die Lösung:

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

In diesem Beispiel, alles, was Sie interessiert, dass der Typ e unterstützt += mit int auf der rechten Seite. Es funktioniert auch für benutzerdefinierte Typen, die operator+=(int) oder operator+=(T) definiert, wobei T ein Typ ist, der implizite Konvertierung von int unterstützt.Es ist, als ob Sie die Programmierung Schnittstelle:

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 
} 

Natürlich würden Sie diese Schleife wie so schreiben:

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

Oder einfach:

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

Es ist immer noch programming to interface.

Aber zur gleichen Zeit, den Kommentar der Punkt in @ David ist erwähnenswert.

Answer 2

In Ihrem ersten Beispiel haben Sie weniger Abhängigkeit von den Elementen des Vektors.

Angenommen, Sie benötigen in einem Monat, dass Ihr Vektor größere Ganzzahlen speichert, also müssen Sie einen std::vector<int64_t> oder einen anderen, breiteren Typ verwenden. Jetzt alle des Codes, der über diesen Vektor iteriert, ist ungültig. Sie werden jeweils ändern müssen:

for (int &e: v) {} 

Für ein:

for (int64_t &e: v) {} 

Aus diesem Grund ist es besser, nur damit auto den internen Typ ableiten. Auf diese Weise können Sie den in Ihrem Vektor gespeicherten Typ für einen anderen, kompatiblen Typ ändern, und der gesamte Code funktioniert weiterhin.