Menü

Iteratoren in STL

iterators stl

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Ein vollständiger Überblick über Iteratoren in STL.

In diesem Tutorial werden die Details der Iteratoren, ihre Typen, Vorteile und die verschiedenen Funktionen, die sie unterstützen, untersucht.

Verwendung der Github-Erweiterung für Visual Studio

Was ist ein Iterator? Im Allgemeinen ist ein Iterator genau wie jedes Objekt, das auf ein bestimmtes Element in einem Datenbereich wie einem Array oder einem Container verweist. Ein Iterator ist wie ein Zeiger in C.

=> Suchen Sie hier nach der gesamten C ++ - Schulungsserie.

ITERATOREN IN STL

Was du lernen wirst:

Überblick

In STL ist ein Iterator ein Objekt, mit dem die Elemente im Container mithilfe einer Reihe von Operatoren wie dem Inkrementoperator (++) oder dem Dereferenzierungsoperator (*) durchlaufen oder durchlaufen werden können.

Iteratoren sind für die STL-Programmierung von entscheidender Bedeutung, da sie neben dem Zugriff auf und der Bearbeitung der in den Containern gespeicherten Daten eine wichtige Rolle bei der Verbindung der Algorithmen mit dem Container spielen.

Arten von Iteratoren

Abhängig von der von den Iteratoren implementierten Funktionalität werden sie wie folgt klassifiziert:

Arten von Iteratoren

  • Eingangs- und Ausgangsiteratoren : Dies sind die einfachsten Arten von Iteratoren. Sie sind am nützlichsten bei sequentiellen Eingabe-Ausgabe-Operationen, die Single-Pass enthalten.
  • Vorwärtsiteratoren : Diese sind wie Eingabe-Iteratoren, haben jedoch eine Richtung, d. H. Eine Vorwärtsrichtung in dem Sinne, dass sie verwendet werden können, um einen Bereich in der Vorwärtsrichtung zu durchlaufen. Wenn Vorwärtsiteratoren nicht konstant sind, können sie auch als Ausgabeiteratoren verwendet werden. Die meisten Standard-STL-Container unterstützen zumindest Forward-Iteratoren.
  • Bidirektionale Iteratoren : Diese ähneln Forward-Iteratoren mit dem einzigen Unterschied, dass sie bidirektional sind. Dies bedeutet, dass wir diese bidirektionalen Iteratoren verwenden können, um den Bereich sowohl in Vorwärts- als auch in Rückwärtsrichtung zu durchlaufen.
  • Iteratoren mit wahlfreiem Zugriff : Iteratoren mit wahlfreiem Zugriff sind unter allen Iteratoren am leistungsstärksten. Dies sind nicht sequentielle Iteratoren. Mit Iteratoren mit wahlfreiem Zugriff können wir auf jeden zufälligen Wert zugreifen, indem wir einen Offset auf den aktuellen Wert anwenden, ohne jedes Element nacheinander durchlaufen zu müssen. Sie zeigen ähnliche Eigenschaften wie Zeiger in C.

Zu beachten ist, dass nicht alle STL-Container alle Iteratoren unterstützen. Unterschiedliche Container unterstützen je nach Anforderung ihrer Funktionalität unterschiedliche Iteratoren.

Unten finden Sie eine Liste der Container, die unterschiedliche Iteratoren verwenden:

BehälterIteratoren
KarteBidirektional
StapelKein Iterator
WarteschlangeKein Iterator
PrioritätswarteschlangeKein Iterator
ListeBidirektional
VektorDirektzugriff
undDirektzugriff
MultimapBidirektional
einstellenBidirektional
MultisetBidirektional

Vorteile von Iteratoren

Iteratoren sind besonders beim Programmieren mit verschiedenen Bereichen und Containern äußerst nützlich.

Einige der Vorteile der Verwendung von Iteratoren bei der Programmierung lassen sich nachfolgend zusammenfassen:

# 1) Wiederverwendbarkeit von Code

Solange wir Iteratoren verwenden, um auf Elemente in unserem Programm zuzugreifen, können wir einfach den Namen des Containers in unserer Iteratordefinition ändern und den Rest des Codes auf ähnliche Weise verwenden, wenn wir den Container ändern müssen.

Dies ist besonders nützlich in Szenarien, in denen ein Vektorcontainer durch einen Listencontainer ersetzt werden soll. Wenn wir anstelle von Iteratoren den Operator () verwenden würden, wäre der Code für den Zugriff auf Elemente beim Ändern der Container nutzlos.

# 2) Einfache und bequeme Programmierung

Iteratoren verfügen über verschiedene integrierte Funktionen, die uns helfen, den Inhalt des Behälters einfach und bequem zu durchlaufen und darauf zuzugreifen.

Zum Beispiel Wir müssen nicht ständig das Ende der Liste oder das Array überprüfen, wie wir es bei der Verwendung von () -Operatoren tun müssen, und wir müssen den Programmcode so ändern, wie wenn wir Elemente hinzufügen möchten, und wir müssen sie für eine Schleife ändern .

Bei Verwendung von Iteratoren können wir direkt auf die Funktionen begin () und end () der Iteratoren zugreifen, ohne dass wir am Ende der Liste einen Überblick behalten müssen, und wir müssen sie auch nicht für eine Schleife ändern.

# 3) Dynamisches Hinzufügen / Entfernen

Während der Verwendung von Iteratoren können wir die Elemente im Container einfach und dynamisch hinzufügen oder entfernen, ohne die Elemente verschieben zu müssen, wie dies in () -Operatoren der Fall ist.

Lassen Sie uns dies anhand des folgenden Beispiels demonstrieren:

#include #include using namespace std; int main() { vector vec1 = { 1, 1, 2 }; // Declaring an iterator vector::iterator i; // Inserting element for (i = vec1.begin(); i != vec1.end(); ++i) { if (i == vec1.begin()) { i = vec1.insert(i, 3); // insert 3 at the beginning of vec1 } } // contents of vec1 3 1 1 2 cout<<'Vector contents after addition'; cout<

Ausgabe:

Vektorinhalt nach Zugabe
3 1 1 2
Vektorinhalt nach dem Löschen
3 1 2

Wie im obigen Beispiel zu sehen ist, können wir mit Iteratoren problemlos Elemente zu einem Container hinzufügen oder daraus entfernen (in diesem Fall Vektor), ohne auf die komplexe Programmierung von Verschiebungselementen und die Umstrukturierung des Containers zurückgreifen zu müssen.

Iteratorfunktionen

Da Iteratoren selbst integrierte Konstrukte sind, unterstützen sie verschiedene Operationen, die für Iteratorobjekte ausgeführt werden können. Diese Operationen / Funktionen ermöglichen es uns, den Bereich effizient zu durchlaufen und auch die Elemente im Container zu manipulieren.

Jetzt werden wir einige wichtige Operationen sehen, die von Iteratoren unterstützt werden.

  • Start: Gibt die erste oder Anfangsposition des Iterators zurück.
  • Ende: Gibt die letzte Position oder die Position nach dem Ende des Iterators zurück.
  • prev: Gibt den neuen Iterator zurück, nachdem die Anzahl der im Argument angegebenen Positionen verringert wurde.
  • Nächster: Gibt einen neuen Iterator zurück, nachdem die Anzahl der im Argument angegebenen Positionen erhöht oder erhöht wurde.
  • Inserter: Fügt das Element an einer beliebigen Position in einen Container ein.
  • Vorauszahlung: Erhöht die Iteratorposition auf die im Argument angegebene Zahl.

Wir werden die Verwendung einiger dieser Funktionen / Operationen im folgenden Programm demonstrieren:

#include #include #include using namespace std; int main() { vector v = { 1, 1,2,3,5 }; // declaring iterators to a vector vector::iterator itr1 = v.begin(); vector::iterator itr2 = v.end(); auto it = next(itr1, 2); // displaying iterator position cout << 'Using next() the new iterator is at: '; cout << *it << ' '; cout << endl; auto it1 = prev(itr2, 2); // displaying iterator position cout << 'The position of new iterator using prev() is: '; cout << *it1 << ' '; cout << endl; //advance advance(itr1,3); // displaying iterator position cout << 'After advance operation,itr1 is positioned at: '; cout << *itr1 << ' '; cout << endl; return 0; }

Ausgabe:

Mit next () befindet sich der neue Iterator bei: 2
Die Position des neuen Iterators mit prev () ist: 3
Nach dem Vorschub wird itr1 positioniert bei: 3

Mit dem obigen Programm haben wir die Verwendung verschiedener Iteratoroperationen demonstriert.

Fazit

Damit sind wir am Ende dieses Tutorials zu Iteratoren angelangt.

Bisher haben wir die Grundlagen von STL besprochen. Ab unserem nächsten Tutorial werden wir mit STL-Containern und deren Programmierung beginnen.

=> Überprüfen Sie hier die komplette C ++ FREE-Schulungsserie.

Literatur-Empfehlungen

^