iterator Class

class QLinkedList::iterator

Die Klasse QLinkedList::iterator bietet einen STL-ähnlichen nicht-konstanten Iterator für QLinkedList. Mehr...

Liste aller Mitglieder, einschließlich geerbter Mitglieder

Öffentliche Funktionen

	iterator()
bool	operator!=(const QLinkedList<T>::const_iterator &other) const
bool	operator!=(const QLinkedList<T>::iterator &other) const
T &	operator*() const
QLinkedList<T>::iterator	operator+(int j) const
QLinkedList<T>::iterator &	operator++()
QLinkedList<T>::iterator	operator++(int)
QLinkedList<T>::iterator &	operator+=(int j)
QLinkedList<T>::iterator	operator-(int j) const
QLinkedList<T>::iterator &	operator--()
QLinkedList<T>::iterator	operator--(int)
QLinkedList<T>::iterator &	operator-=(int j)
T *	operator->() const
bool	operator==(const QLinkedList<T>::const_iterator &other) const
bool	operator==(const QLinkedList<T>::iterator &other) const

Detaillierte Beschreibung

QLinkedList bietet sowohl Iteratoren im STL-Stil als auch Iteratoren im Java-Stil. Die Iteratoren im STL-Stil sind einfacher und umständlicher zu benutzen; andererseits sind sie etwas schneller und haben für Entwickler, die STL bereits kennen, den Vorteil der Vertrautheit.

QLinkedList<T>::iterator ermöglicht es, über ein QLinkedList<T> zu iterieren und das mit dem Iterator verbundene Listenelement zu ändern. Wenn Sie über eine const QLinkedList iterieren wollen, verwenden Sie stattdessen QLinkedList::const_iterator. Es ist im Allgemeinen eine gute Praxis, QLinkedList::const_iterator auch für eine nicht-konstante QLinkedList zu verwenden, es sei denn, Sie müssen die QLinkedList durch den Iterator ändern. Konst-Iteratoren sind etwas schneller und können die Lesbarkeit des Codes verbessern.

Der Standard-Konstruktor QLinkedList::iterator erzeugt einen nicht initialisierten Iterator. Sie müssen ihn mit einer Funktion wie QLinkedList::begin(), QLinkedList::end() oder QLinkedList::insert() initialisieren, bevor Sie mit der Iteration beginnen können. Hier ist eine typische Schleife, die alle in einer Liste gespeicherten Elemente ausgibt:

QLinkedList<QString> list;
list.append("January");
list.append("February");
...
list.append("December");

QLinkedList<QString>::iterator i;
for (i = list.begin(); i != list.end(); ++i)
    cout << *i << Qt::endl;

STL-artige Iteratoren können als Argumente für generic algorithms verwendet werden. Hier sehen Sie zum Beispiel, wie man ein Element in der Liste findet:

QLinkedList<QString> list;
...
QLinkedList<QString>::iterator it = std::find(list.begin(),
                                              list.end(), "Joel");
if (it != list.end())
    cout << "Found Joel" << Qt::endl;

Sehen wir uns einige Beispiele für Dinge an, die wir mit QLinkedList::iterator tun können, die wir mit QLinkedList::const_iterator nicht tun können. Hier ist ein Beispiel, das jeden in QLinkedList<int> gespeicherten Wert um 2 inkrementiert:

QLinkedList<int>::iterator i;
for (i = list.begin(); i != list.end(); ++i)
    *i += 2;

Hier ist ein Beispiel, das alle Elemente entfernt, die mit einem Unterstrich in einem QLinkedList<QString> beginnen:

QLinkedList<QString> list;
...
QLinkedList<QString>::iterator i = list.begin();
while (i != list.end()) {
    if ((*i).startsWith('_'))
        i = list.erase(i);
    else
        ++i;
}

Der Aufruf von QLinkedList::erase() entfernt das Element, auf das der Iterator zeigt, aus der Liste und gibt einen Iterator zum nächsten Element zurück. Hier ist eine weitere Möglichkeit, ein Element beim Iterieren zu entfernen:

QLinkedList<QString>::iterator i = list.begin();
while (i != list.end()) {
    QLinkedList<QString>::iterator previous = i;
    ++i;
    if ((*previous).startsWith('_'))
        list.erase(previous);
}

Es mag verlockend sein, Code wie diesen zu schreiben:

// WRONG
while (i != list.end()) {
    if ((*i).startsWith('_'))
        list.erase(i);
    ++i;
}

Dies führt jedoch möglicherweise zu einem Absturz in ++i, da i ein hängender Iterator nach dem Aufruf von erase() ist.

Mehrere Iteratoren können für dieselbe Liste verwendet werden. Wenn Sie der Liste Elemente hinzufügen, bleiben die vorhandenen Iteratoren gültig. Wenn Sie Elemente aus der Liste entfernen, werden Iteratoren, die auf die entfernten Elemente verweisen, zu Dangling-Iteratoren.

Warnung: Iteratoren auf implizit gemeinsam genutzten Containern funktionieren nicht genau wie STL-Iteratoren. Sie sollten es vermeiden, einen Container zu kopieren, während Iteratoren auf diesem Container aktiv sind. Für weitere Informationen lesen Sie Implizite gemeinsame Nutzung Iterator Problem.

Siehe auch QLinkedList::const_iterator und QMutableLinkedListIterator.

Dokumentation der Mitgliedsfunktionen

bool iterator::operator==(const QLinkedList<T>::const_iterator &other) const

bool iterator::operator==(const QLinkedList<T>::iterator &other) const

Gibt true zurück, wenn other auf dasselbe Element wie dieser Iterator zeigt; andernfalls wird false zurückgegeben.

Siehe auch operator!=().

bool iterator::operator!=(const QLinkedList<T>::const_iterator &other) const

bool iterator::operator!=(const QLinkedList<T>::iterator &other) const

Gibt true zurück, wenn other auf ein anderes Element als diesen Iterator zeigt; andernfalls wird false zurückgegeben.

Siehe auch operator==().

iterator::iterator()

Konstruiert einen uninitialisierten Iterator.

Funktionen wie operator*() und operator++() sollten nicht mit einem nicht initialisierten Iterator aufgerufen werden. Verwenden Sie operator=(), um ihm einen Wert zuzuweisen, bevor Sie ihn verwenden.

Siehe auch QLinkedList::begin() und QLinkedList::end().

T &iterator::operator*() const

Gibt einen änderbaren Verweis auf das aktuelle Element zurück.

Sie können den Wert eines Elements ändern, indem Sie z. B. operator*() auf der linken Seite einer Zuweisung verwenden:

if (*it == "Hello")
    *it = "Bonjour";

Siehe auch operator->().

QLinkedList<T>::iterator iterator::operator+(int j) const

Gibt einen Iterator zu dem Element an j Positionen vor diesem Iterator zurück. (Wenn j negativ ist, geht der Iterator rückwärts.)

Dieser Vorgang kann bei großen j Werten langsam sein.

Siehe auch operator-().

QLinkedList<T>::iterator &iterator::operator++()

Der Präfix-Operator ++ (++it) setzt den Iterator auf das nächste Element in der Liste und gibt einen Iterator auf das neue aktuelle Element zurück.

Der Aufruf dieser Funktion auf QLinkedList::end() führt zu undefinierten Ergebnissen.

Siehe auch operator--().

QLinkedList<T>::iterator iterator::operator++(int)

Dies ist eine überladene Funktion.

Der Postfix-Operator ++ (it++) setzt den Iterator auf das nächste Element in der Liste und gibt einen Iterator auf das zuvor aktuelle Element zurück.

QLinkedList<T>::iterator &iterator::operator+=(int j)

Bringt den Iterator um j Elemente weiter. (Wenn j negativ ist, geht der Iterator rückwärts.)

Siehe auch operator-=() und operator+().

QLinkedList<T>::iterator iterator::operator-(int j) const

Gibt einen Iterator zu dem Element an j Positionen rückwärts von diesem Iterator zurück. (Wenn j negativ ist, geht der Iterator vorwärts.)

Dieser Vorgang kann bei großen j Werten langsam sein.

Siehe auch operator+().

QLinkedList<T>::iterator &iterator::operator--()

Der Präfix-Operator (--it) macht das vorhergehende Element aktuell und gibt einen Iterator zum neuen aktuellen Element zurück.

Der Aufruf dieser Funktion auf QLinkedList::begin() führt zu undefinierten Ergebnissen.

Siehe auch operator++().

QLinkedList<T>::iterator iterator::operator--(int)

Dies ist eine überladene Funktion.

Der Postfix-Operator (it--) macht das vorangehende Element aktuell und gibt einen Iterator zum zuvor aktuellen Element zurück.

QLinkedList<T>::iterator &iterator::operator-=(int j)

Bringt den Iterator dazu, um j Elemente zurück zu gehen. (Wenn j negativ ist, geht der Iterator vorwärts.)

Siehe auch operator+=() und operator-().

T *iterator::operator->() const

Gibt einen Zeiger auf das aktuelle Element zurück.

Siehe auch operator*().

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.