Iteratoren im Java-Stil in Qt

Iteratoren im Java-Stil

Für jede Containerklasse gibt es zwei Iterator-Datentypen im Java-Stil: einen, der Lesezugriff bietet, und einen, der Lese- und Schreibzugriff bietet.

In dieser Erörterung konzentrieren wir uns auf QList und QMap. Die Iteratortypen für QSet haben genau dieselbe Schnittstelle wie die Iteratoren von QList; ebenso haben die Iteratortypen für QHash dieselbe Schnittstelle wie die Iteratoren von QMap.

Im Gegensatz zu Iteratoren im STL-Stil verweisen Iteratoren im Java-Stil nicht direkt auf Elemente, sondern auf die Position zwischen ihnen. Aus diesem Grund verweisen sie entweder auf den Anfang des Containers (vor dem ersten Element), auf das Ende des Containers (nach dem letzten Element) oder auf die Position zwischen zwei Elementen. Das folgende Diagramm zeigt die gültigen Iteratorpositionen als rote Pfeile für eine Liste mit vier Elementen:

Hier ist eine typische Schleife, um alle Elemente eines „ QList “ <QString> der Reihe nach zu durchlaufen:

QList<QString> list = {"A", "B", "C", "D"};

QListIterator<QString> i(list);
while (i.hasNext())
    QString s = i.next();

Sie funktioniert wie folgt: Der zu durchlaufende „ QList “ wird an den Konstruktor von „ QListIterator “ übergeben. Zu diesem Zeitpunkt befindet sich der Iterator direkt vor dem ersten Element der Liste (vor dem Element „A“). Anschließend rufen wir ` hasNext()` auf, um zu prüfen, ob sich ein Element hinter dem Iterator befindet. Ist dies der Fall, rufen wir ` next()` auf, um dieses Element zu überspringen. Die Funktion `next()` gibt das Element zurück, über das gesprungen wird. Bei einem ` QList` <QString> ist dieses Element vom Typ ` QString`.

So iteriert man rückwärts in einer „ QList “:

QListIterator<QString> i(list);
i.toBack();
while (i.hasPrevious())
    QString s = i.previous();

Der Code ist symmetrisch zum Vorwärtsdurchlaufen, mit dem Unterschied, dass wir zunächst ` toBack()` aufrufen, um den Iterator hinter das letzte Element der Liste zu verschieben.

Das folgende Diagramm veranschaulicht die Auswirkungen des Aufrufs von ` next()` und ` previous()` auf einen Iterator:

Die folgende Tabelle fasst die QListIterator -API zusammen:

QListIterator bietet keine Funktionen zum Einfügen oder Entfernen von Elementen aus der Liste während der Iteration. Dazu müssen Sie ` QMutableListIterator` verwenden. Hier ist ein Beispiel, in dem wir alle ungeraden Zahlen aus einem ` QList<int>` mithilfe von ` QMutableListIterator` entfernen:

QMutableListIterator<int> i(list);
while (i.hasNext()) {
    if (i.next() % 2 != 0)
        i.remove();
}

Der Aufruf von `next()` in der Schleife erfolgt jedes Mal. Er springt zum nächsten Element in der Liste. Die Funktion ` remove()` entfernt das letzte Element, über das wir gesprungen sind, aus der Liste. Der Aufruf von ` remove()` macht den Iterator nicht ungültig, sodass er weiterhin sicher verwendet werden kann. Dies funktioniert ebenso gut beim Rückwärtsdurchlaufen:

QMutableListIterator<int> i(list);
i.toBack();
while (i.hasPrevious()) {
    if (i.previous() % 2 != 0)
        i.remove();
}

Wenn wir lediglich den Wert eines vorhandenen Elements ändern möchten, können wir ` setValue()` verwenden. Im folgenden Code ersetzen wir jeden Wert, der größer als 128 ist, durch 128:

QMutableListIterator<int> i(list);
while (i.hasNext()) {
    if (i.next() > 128)
        i.setValue(128);
}

Genau wie ` remove()` wirkt sich auch ` setValue()` auf das letzte Element aus, über das wir gesprungen sind. Bei der Vorwärtsiteration ist dies das Element unmittelbar vor dem Iterator; bei der Rückwärtsiteration ist dies das Element unmittelbar nach dem Iterator.

Die Funktion ` next()` gibt eine nicht-konstante Referenz auf das Element in der Liste zurück. Für einfache Operationen benötigen wir ` setValue()` gar nicht:

QMutableListIterator<int> i(list);
while (i.hasNext())
    i.next() *= 2;

Wie oben erwähnt, haben die Iterator-Klassen von ` QSet` genau dieselbe API wie die von ` QList`. Wir wenden uns nun ` QMapIterator` zu, das sich etwas unterscheidet, da es über (Schlüssel, Wert)-Paare iteriert.

Wie QListIterator bietet auch QMapIterator die Methoden toFront(), toBack(), hasNext(), next(), peekNext(), hasPrevious(), previous() und peekPrevious(). Die Schlüssel- und Wertkomponenten werden durch Aufruf von key() und value() auf das Objekt extrahiert, das von next(), peekNext(), previous() oder peekPrevious() zurückgegeben wird.

Das folgende Beispiel entfernt alle (Hauptstadt, Land)-Paare, bei denen der Name der Hauptstadt mit „City“ endet:

QMap<QString, QString> map = {
    {"Paris", "France"},
    {"Guatemala City", "Guatemala"},
    {"Mexico City", "Mexico"},
    {"Moscow", "Russia"}
};
//...

QMutableMapIterator<QString, QString> i(map);
while (i.hasNext()) {
    if (i.next().key().endsWith("City"))
        i.remove();
}

QMapIterator bietet außerdem die Funktionen „ key()“ und „ value()“, die direkt auf den Iterator angewendet werden und den Schlüssel sowie den Wert des letzten Elements zurückgeben, über das der Iterator gesprungen ist. Der folgende Code kopiert beispielsweise den Inhalt von „ QMap “ in „ QHash “:

QMap<int, QWidget *> map;
QHash<int, QWidget *> hash;

QMapIterator<int, QWidget *> i(map);
while (i.hasNext()) {
    i.next();
    hash.insert(i.key(), i.value());
}

Wenn wir alle Elemente mit demselben Wert durchlaufen möchten, können wir ` findNext()` oder ` findPrevious()` verwenden. Hier ist ein Beispiel, in dem wir alle Elemente mit einem bestimmten Wert entfernen:

QMutableMapIterator<int, QWidget *> i(map);
while (i.findNext(widget))
    i.remove();