Ich bin neu in der C ++ - Sprache. Ich habe angefangen, Vektoren zu verwenden, und habe festgestellt, dass in dem gesamten Code, den ich sehe, um einen Vektor über Indizes zu iterieren, der erste Parameter der forSchleife immer auf dem Vektor basiert. In Java könnte ich so etwas mit einer ArrayList machen:

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

Gibt es einen Grund, warum ich das in C ++ nicht sehe? Ist es schlechte Praxis?

Gibt es einen Grund, warum ich das in C ++ nicht sehe? Ist es schlechte Praxis?

Nein. Es ist keine schlechte Praxis, aber der folgende Ansatz verleiht Ihrem Code eine gewisse Flexibilität .

Normalerweise verwendet der Code zum Iterieren über Containerelemente vor C ++ 11 Iteratoren, etwa:

std::vector<int>::iterator it = vector.begin();

Dies liegt daran, dass der Code dadurch flexibler wird.

Alle Standardbibliothekscontainer unterstützen und bieten Iteratoren. Wenn Sie zu einem späteren Zeitpunkt der Entwicklung zu einem anderen Container wechseln müssen, muss dieser Code nicht geändert werden.

Hinweis: Das Schreiben von Code, der mit jedem möglichen Standardbibliothekscontainer funktioniert, ist nicht so einfach, wie es scheint.

Der Grund, warum Sie eine solche Praxis nicht sehen, ist ziemlich subjektiv und kann keine eindeutige Antwort haben, da ich viele der Codes gesehen habe, die Ihre erwähnte Methode anstelle von iteratorStilcode verwenden.

Folgendes kann Gründe dafür sein, dass Menschen nicht über die vector.size()Art der Schleife nachdenken:

1. Paranoid sein, size()wenn Sie jedes Mal in der Schleifenbedingung anrufen . Entweder ist es kein Problem oder es kann trivial behoben werden
2. Bevorzugen std::for_each()Sie die forSchleife selbst
3. Später Wechsel des Behälters aus std::vectorzu anderen (zB map, list) wird auch die Änderung des Schleifenmechanismus verlangen, weil nicht jeder Container Unterstützung size()Stil der Looping

C ++ 11 bietet eine gute Möglichkeit, sich durch die Container zu bewegen. Dies wird als "Bereich basierend auf Schleife" (oder "erweitert für Schleife" in Java) bezeichnet.

Mit wenig Code können Sie das Ganze durchlaufen (obligatorisch!) std::vector:

vector<int> vi;
...
for(int i : vi) 
  cout << "i = " << i << endl;

Die sauberste Art, einen Vektor zu durchlaufen, sind Iteratoren:

for (auto it = begin (vector); it != end (vector); ++it) {
    it->doSomething ();
}

oder (entspricht dem oben genannten)

for (auto & element : vector) {
    element.doSomething ();
}

Vor C ++ 0x müssen Sie auto durch den Iteratortyp ersetzen und Elementfunktionen anstelle der globalen Funktionen begin und end verwenden.

Das haben Sie wahrscheinlich gesehen. Im Vergleich zu dem von Ihnen erwähnten Ansatz besteht der Vorteil darin, dass Sie nicht stark von der Art der abhängig sind vector. Wenn Sie vectorzu einer anderen Klasse vom Typ "Sammlung" wechseln , funktioniert Ihr Code wahrscheinlich weiterhin. Ähnliches können Sie jedoch auch in Java tun. Konzeptionell gibt es keinen großen Unterschied. C ++ verwendet jedoch Vorlagen, um dies zu implementieren (im Vergleich zu Generika in Java). daher wird der Ansatz für alle Arten arbeiten , für die beginund endFunktionen definiert sind, auch für Nicht-Klasse - Typen wie statische Arrays. Siehe hier: Wie funktioniert die bereichsbasierte Funktion für einfache Arrays?

Der richtige Weg, dies zu tun, ist:

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

Dabei ist T der Typ der Klasse innerhalb des Vektors. Wenn die Klasse beispielsweise CActivity war, schreiben Sie einfach CActivity anstelle von T.

Diese Art von Methode funktioniert auf jeder STL (nicht nur Vektoren, was etwas besser ist).

Wenn Sie weiterhin Indizes verwenden möchten, gehen Sie wie folgt vor:

for(std::vector<T>::size_type i = 0; i != v.size(); i++) {
    v[i].doSomething();
}

Es gibt einige starke Gründe, Iteratoren zu verwenden, von denen einige hier erwähnt werden:

Ein späterer Containerwechsel macht Ihren Code nicht ungültig.

Wenn Sie also von einem std :: -Vektor zu einer std :: -Liste oder einem std :: -Satz wechseln, können Sie keine numerischen Indizes verwenden, um zu Ihrem enthaltenen Wert zu gelangen. Die Verwendung eines Iterators ist weiterhin gültig.

Laufzeitabfangen ungültiger Iteration

Wenn Sie Ihren Container in der Mitte Ihrer Schleife ändern, wird bei der nächsten Verwendung Ihres Iterators eine ungültige Iteratorausnahme ausgelöst.

Ich war überrascht, dass niemand erwähnt hat, dass das Durchlaufen eines Arrays mit einem ganzzahligen Index es Ihnen leicht macht, fehlerhaften Code zu schreiben, indem Sie ein Array mit dem falschen Index abonnieren. Wenn Sie beispielsweise verschachtelte Schleifen mit iund jals Indizes haben, können Sie ein Array mit jund nicht falsch abonnieren iund somit einen Fehler in das Programm einfügen.

Im Gegensatz dazu sind die anderen hier aufgeführten Formen, nämlich die bereichsbasierte forSchleife und die Iteratoren, viel weniger fehleranfällig. Die Semantik der Sprache und der Typprüfungsmechanismus des Compilers verhindern, dass Sie versehentlich mit dem falschen Index auf ein Array zugreifen.

Mit STL verwenden Programmierer das iteratorsDurchlaufen von Containern, da der Iterator ein abstraktes Konzept ist, das in allen Standardcontainern implementiert ist. Zum Beispiel std::listhat überhaupt keine operator [].

Die Verwendung des Auto-Operators macht die Verwendung wirklich einfach, da Sie sich nicht um den Datentyp und die Größe des Vektors oder einer anderen Datenstruktur kümmern müssen

Iterierender Vektor mit auto und for loop

vector<int> vec = {1,2,3,4,5}

for(auto itr : vec)
    cout << itr << " ";

Ausgabe:

1 2 3 4 5

Sie können diese Methode auch verwenden, um Sätze und Listen zu iterieren. Mit Auto erkennt automatisch den Datentyp in der Vorlage verwendet und können Sie es verwenden. Also, auch wenn ich eine hatte vectordie stringoder chardie gleiche Syntax wird gut funktionieren

Die richtige Methode zum Iterieren der Schleife und zum Drucken ihrer Werte lautet wie folgt:

#include<vector>

//declare the vector of type int
vector<int> v;

//insert the 5 element in the vector
for ( unsigned int i = 0; i < 5; i++){
    v.push_back(i);
}

//print those element
for (auto it = 0; it < v.end(); i++){
    std::cout << *it << std::endl;
}

Hier ist eine einfachere Möglichkeit, Werte im Vektor zu iterieren und zu drucken.

for(int x: A) // for integer x in vector A
    cout<< x <<" "; 

 //different declaration type
    vector<int>v;  
    vector<int>v2(5,30); //size is 5 and fill up with 30
    vector<int>v3={10,20,30};
    
    //From C++11 and onwards
    for(auto itr:v2)
        cout<<"\n"<<itr;
     
     //(pre c++11)   
    for(auto itr=v3.begin(); itr !=v3.end(); itr++)
        cout<<"\n"<<*itr;