Was ist die richtige Methode zum Iterieren über einen Vektor in C ++?

Betrachten Sie diese beiden Codefragmente, dieses funktioniert gut:

for (unsigned i=0; i < polygon.size(); i++) {
    sum += polygon[i];
}

und das hier:

for (int i=0; i < polygon.size(); i++) {
    sum += polygon[i];
}

was erzeugt warning: comparison between signed and unsigned integer expressions.

Ich bin neu in der Welt von C ++, daher unsignedsieht die Variable für mich etwas beängstigend aus und ich weiß, dass unsignedVariablen gefährlich sein können, wenn sie nicht richtig verwendet werden. Ist das also richtig?

Informationen zum Rückwärtslaufen finden Sie in dieser Antwort .

Vorwärts iterieren ist fast identisch. Ändern Sie einfach die Iteratoren / Swap-Dekremente schrittweise. Sie sollten Iteratoren bevorzugen. Einige Leute sagen Ihnen, dass Sie std::size_tals Indexvariablentyp verwenden sollen. Dies ist jedoch nicht tragbar. Verwenden size_typeSie immer das typedef des Containers (Während Sie im vorwärts iterierenden Fall nur mit einer Konvertierung davonkommen könnten, könnte es im rückwärts iterierenden Fall bei der Verwendung tatsächlich ganz schief gehen std::size_t, falls std::size_tes breiter ist als das typedef von size_type). ::

Verwenden von std :: vector

Iteratoren verwenden

for(std::vector<T>::iterator it = v.begin(); it != v.end(); ++it) {
    /* std::cout << *it; ... */
}

Wichtig ist, dass Sie immer das Präfix-Inkrement-Formular für Iteratoren verwenden, deren Definitionen Sie nicht kennen. Dadurch wird sichergestellt, dass Ihr Code so allgemein wie möglich ausgeführt wird.

Verwenden von Range C ++ 11

for(auto const& value: a) {
     /* std::cout << value; ... */

Indizes verwenden

for(std::vector<int>::size_type i = 0; i != v.size(); i++) {
    /* std::cout << v[i]; ... */
}

Arrays verwenden

Iteratoren verwenden

for(element_type* it = a; it != (a + (sizeof a / sizeof *a)); it++) {
    /* std::cout << *it; ... */
}

Verwenden von Range C ++ 11

for(auto const& value: a) {
     /* std::cout << value; ... */

Indizes verwenden

for(std::size_t i = 0; i != (sizeof a / sizeof *a); i++) {
    /* std::cout << a[i]; ... */
}

Lesen Sie in der rückwärts iterierenden Antwort, zu welchem ​​Problem der sizeofAnsatz führen kann.

Vier Jahre vergingen, Google gab mir diese Antwort. Mit dem Standard- C ++ 11 (auch bekannt als C ++ 0x ) gibt es tatsächlich eine neue angenehme Möglichkeit (zum Preis der Unterbrechung der Abwärtskompatibilität): das neue autoSchlüsselwort. Dies erspart Ihnen die Mühe, den Typ des zu verwendenden Iterators explizit angeben zu müssen (wobei der Vektortyp erneut wiederholt wird), wenn (für den Compiler) klar ist, welcher Typ verwendet werden soll. Mit vIhrem sein vector, können Sie etwas tun , wie folgt:

for ( auto i = v.begin(); i != v.end(); i++ ) {
    std::cout << *i << std::endl;
}

C ++ 11 geht noch weiter und bietet Ihnen eine spezielle Syntax zum Durchlaufen von Sammlungen wie Vektoren. Es beseitigt die Notwendigkeit, Dinge zu schreiben, die immer gleich sind:

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

Erstellen Sie eine Datei, um sie in einem Arbeitsprogramm anzuzeigen auto.cpp:

#include <vector>
#include <iostream>

int main(void) {
    std::vector<int> v = std::vector<int>();
    v.push_back(17);
    v.push_back(12);
    v.push_back(23);
    v.push_back(42);
    for ( auto &i : v ) {
        std::cout << i << std::endl;
    }
    return 0;
}

Wenn Sie dies mit g ++ kompilieren , müssen Sie es normalerweise so einstellen, dass es mit dem neuen Standard funktioniert, indem Sie ein zusätzliches Flag angeben:

g++ -std=c++0x -o auto auto.cpp

Jetzt können Sie das Beispiel ausführen:

$ ./auto
17
12
23
42

Bitte beachten Sie, dass die Anweisungen zum Kompilieren und Ausführen spezifisch für den gnu c ++ - Compiler unter Linux sind. Das Programm sollte plattform- (und compiler-) unabhängig sein.

In dem speziellen Fall in Ihrem Beispiel würde ich die STL-Algorithmen verwenden, um dies zu erreichen.

#include <numeric> 

sum = std::accumulate( polygon.begin(), polygon.end(), 0 );

Für einen allgemeineren, aber immer noch recht einfachen Fall würde ich gehen mit:

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

using namespace boost::lambda;
std::for_each( polygon.begin(), polygon.end(), sum += _1 );

Zur Antwort von Johannes Schaub:

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

Das mag mit einigen Compilern funktionieren, aber nicht mit gcc. Das Problem hierbei ist die Frage, ob std :: vector :: iterator ein Typ, eine Variable (Mitglied) oder eine Funktion (Methode) ist. Wir bekommen den folgenden Fehler mit gcc:

In member function ‘void MyClass<T>::myMethod()’:
error: expected `;' before ‘it’
error: ‘it’ was not declared in this scope
In member function ‘void MyClass<T>::sort() [with T = MyClass]’:
instantiated from ‘void MyClass<T>::run() [with T = MyClass]’
instantiated from here
dependent-name ‘std::vector<T*,std::allocator<T*> >::iterator’ is parsed as a non-type, but instantiation yields a type
note: say ‘typename std::vector<T*,std::allocator<T*> >::iterator’ if a type is meant

Die Lösung verwendet das Schlüsselwort 'Typname' wie folgt:

typename std::vector<T*>::iterator it = v.begin();
for( ; it != v.end(); ++it) {
...

Ein Aufruf von vector<T>::size()gibt einen Wert vom Typ zurück std::vector<T>::size_type, nicht int, unsigned int oder anderweitig.

Im Allgemeinen wird die Iteration über einen Container in C ++ mithilfe solcher Iteratoren durchgeführt .

std::vector<T>::iterator i = polygon.begin();
std::vector<T>::iterator end = polygon.end();

for(; i != end; i++){
    sum += *i;
}

Wobei T der Datentyp ist, den Sie im Vektor speichern.

Oder die verschiedenen Iterationsalgorithmen mit ( std::transform, std::copy, std::fill, std::for_eachet cetera).

Verwendung size_t:

for (size_t i=0; i < polygon.size(); i++)

Wikipedia zitieren :

Die Header-Dateien stdlib.h und stddef.h definieren einen Datentyp namens, size_tder zur Darstellung der Größe eines Objekts verwendet wird. Bibliotheksfunktionen, die Größen annehmen, erwarten, dass sie vom Typ sind size_t, und der Operator sizeof wertet aus size_t.

Der tatsächliche Typ von size_tist plattformabhängig; Ein häufiger Fehler ist die Annahme size_t, dass es sich um int ohne Vorzeichen handelt, was zu Programmierfehlern führen kann, insbesondere wenn 64-Bit-Architekturen häufiger eingesetzt werden.

Ein bisschen Geschichte:

Verwenden Sie ein Vorzeichenbit, um darzustellen, ob eine Zahl negativ ist oder nicht. intist ein vorzeichenbehafteter Datentyp, der positive und negative Werte enthalten kann (etwa -2 bis 2 Milliarden). Unsignedkann nur positive Zahlen speichern (und da es kein bisschen an Metadaten verschwendet, kann es mehr speichern: 0 bis ungefähr 4 Milliarden).

std::vector::size()gibt ein zurück unsigned, denn wie könnte ein Vektor eine negative Länge haben?

Die Warnung sagt Ihnen, dass der rechte Operand Ihrer Ungleichheitsanweisung mehr Daten enthalten kann als der linke.

Wenn Sie einen Vektor mit mehr als 2 Milliarden Einträgen haben und eine Ganzzahl zum Indizieren verwenden, treten im Wesentlichen Überlaufprobleme auf (der int wird auf negative 2 Milliarden zurückgesetzt).

Normalerweise benutze ich BOOST_FOREACH:

#include <boost/foreach.hpp>

BOOST_FOREACH( vector_type::value_type& value, v ) {
    // do something with 'value'
}

Es funktioniert mit STL-Containern, Arrays, Strings im C-Stil usw.

Um vollständig zu sein, aktiviert die C ++ 11-Syntax nur eine andere Version für Iteratoren ( ref ):

for(auto it=std::begin(polygon); it!=std::end(polygon); ++it) {
  // do something with *it
}

Das ist auch bequem für die umgekehrte Iteration

for(auto it=std::end(polygon)-1; it!=std::begin(polygon)-1; --it) {
  // do something with *it
}

In C ++ 11

Ich würde allgemeine Algorithmen verwenden for_each, um die Suche nach dem richtigen Typ von Iterator und Lambda-Ausdruck zu vermeiden, um zusätzliche benannte Funktionen / Objekte zu vermeiden.

Das kurze "hübsche" Beispiel für Ihren speziellen Fall (vorausgesetzt, Polygon ist ein Vektor von ganzen Zahlen):

for_each(polygon.begin(), polygon.end(), [&sum](int i){ sum += i; });

getestet auf: http://ideone.com/i6Ethd

Vergessen Sie nicht, Folgendes anzugeben : Algorithmus und natürlich Vektor :)

Microsoft hat tatsächlich auch ein schönes Beispiel dafür:
Quelle: http://msdn.microsoft.com/en-us/library/dd293608.aspx

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int main() 
{
   // Create a vector object that contains 10 elements.
   vector<int> v;
   for (int i = 1; i < 10; ++i) {
      v.push_back(i);
   }

   // Count the number of even numbers in the vector by 
   // using the for_each function and a lambda.
   int evenCount = 0;
   for_each(v.begin(), v.end(), [&evenCount] (int n) {
      cout << n;
      if (n % 2 == 0) {
         cout << " is even " << endl;
         ++evenCount;
      } else {
         cout << " is odd " << endl;
      }
   });

   // Print the count of even numbers to the console.
   cout << "There are " << evenCount 
        << " even numbers in the vector." << endl;
}

for (vector<int>::iterator it = polygon.begin(); it != polygon.end(); it++)
    sum += *it; 

Der erste ist typrichtig und im engeren Sinne korrekt. (Wenn Sie darüber nachdenken, kann die Größe niemals kleiner als Null sein.) Diese Warnung scheint mir jedoch einer der guten Kandidaten zu sein, um ignoriert zu werden.

Überlegen Sie, ob Sie überhaupt iterieren müssen

Der <algorithm>Standard-Header bietet uns dafür folgende Möglichkeiten:

using std::begin;  // allows argument-dependent lookup even
using std::end;    // if the container type is unknown here
auto sum = std::accumulate(begin(polygon), end(polygon), 0);

Andere Funktionen in der Algorithmusbibliothek führen allgemeine Aufgaben aus. Stellen Sie sicher, dass Sie wissen, was verfügbar ist, wenn Sie sich Mühe sparen möchten.

Dunkles, aber wichtiges Detail: Wenn Sie wie folgt "for (auto it)" sagen, erhalten Sie eine Kopie des Objekts, nicht das eigentliche Element:

struct Xs{int i} x;
x.i = 0;
vector <Xs> v;
v.push_back(x);
for(auto it : v)
    it.i = 1;         // doesn't change the element v[0]

Um die Elemente des Vektors zu ändern, müssen Sie den Iterator als Referenz definieren:

for(auto &it : v)

Wenn Ihr Compiler dies unterstützt, können Sie einen Bereich verwenden, der auf basiert, um auf die Vektorelemente zuzugreifen:

vector<float> vertices{ 1.0, 2.0, 3.0 };

for(float vertex: vertices){
    std::cout << vertex << " ";
}

Drucke: 1 2 3. Beachten Sie, dass Sie diese Technik nicht zum Ändern der Elemente des Vektors verwenden können.

Die beiden Codesegmente funktionieren gleich. Die vorzeichenlose int "-Route ist jedoch korrekt. Die Verwendung von vorzeichenlosen int-Typen funktioniert besser mit dem Vektor in der von Ihnen verwendeten Instanz. Wenn Sie die Elementfunktion size () für einen Vektor aufrufen, wird ein vorzeichenloser ganzzahliger Wert zurückgegeben, sodass Sie die Variable vergleichen möchten "i" auf einen Wert seines eigenen Typs.

Wenn Sie sich immer noch nicht sicher sind, wie "unsigned int" in Ihrem Code aussieht, versuchen Sie es mit "uint". Dies ist im Grunde eine verkürzte Version von "unsigned int" und es funktioniert genauso. Sie müssen auch keine anderen Header einfügen, um es zu verwenden.

Fügen Sie dies hinzu, da ich es in keiner Antwort erwähnt finden konnte: Für die indexbasierte Iteration können wir verwenden, decltype(vec_name.size())welche zu bewerten wärestd::vector<T>::size_type

Beispiel

for(decltype(v.size()) i{ 0 }; i < v.size(); i++) {
    /* std::cout << v[i]; ... */
}