Itérateurs de type Java dans Qt

Itérateurs de type Java

Pour chaque classe de conteneur, il existe deux types de données d'itérateur de style Java : l'un offrant un accès en lecture seule et l'autre un accès en lecture-écriture.

Dans cette discussion, nous nous concentrerons sur QList et QMap. Les types d’itérateurs de QSet ont exactement la même interface que ceux de QList; de même, les types d’itérateurs de QHash ont la même interface que ceux de QMap.

Contrairement aux itérateurs de type STL, les itérateurs de type Java pointent entre les éléments plutôt que directement vers ceux-ci. Pour cette raison, ils pointent soit vers le tout début du conteneur (avant le premier élément), soit vers la toute fin du conteneur (après le dernier élément), soit entre deux éléments. Le schéma ci-dessous illustre les positions valides des itérateurs sous forme de flèches rouges pour une liste contenant quatre éléments :

Voici une boucle typique permettant de parcourir tous les éléments d’un QList<QString> dans l’ordre :

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

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

Elle fonctionne comme suit : l’ QList sur laquelle il faut itérer est transmise au constructeur QListIterator. À ce stade, l’itérateur se trouve juste avant le premier élément de la liste (avant l’élément « A »). Ensuite, nous appelons hasNext() pour vérifier s’il y a un élément après l’itérateur. Si c’est le cas, nous appelons next() pour sauter cet élément. La fonction next() renvoie l’élément qu’elle a sauté. Pour un QList<QString>, cet élément est de type QString.

Voici comment parcourir une liste QList en arrière :

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

Le code est symétrique par rapport à l’itération vers l’avant, à l’exception du fait que l’on commence par appeler ` toBack()` pour déplacer l’itérateur après le dernier élément de la liste.

Le diagramme ci-dessous illustre l’effet de l’appel de ` next()` et de ` previous()` sur un itérateur :

Le tableau suivant résume l'API ` QListIterator ` :

QListIterator ne fournit aucune fonction permettant d’insérer ou de supprimer des éléments de la liste au cours de l’itération. Pour ce faire, vous devez utiliser ` QMutableListIterator`. Voici un exemple dans lequel nous supprimons tous les nombres impairs d’une liste ` QList<int>` à l’aide de ` QMutableListIterator` :

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

L'appel à `next()` dans la boucle est effectué à chaque itération. Il permet de passer à l'élément suivant de la liste. La fonction ` remove()` supprime de la liste le dernier élément que nous venons de sauter. L'appel à ` remove()` n'invalide pas l'itérateur ; vous pouvez donc continuer à l'utiliser en toute sécurité. Cela fonctionne tout aussi bien lors d'une itération vers l'arrière :

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

Si l’on souhaite simplement modifier la valeur d’un élément existant, on peut utiliser ` setValue()`. Dans le code ci-dessous, on remplace toute valeur supérieure à 128 par 128 :

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

Tout comme remove(), setValue() agit sur le dernier élément que nous avons sauté. Si nous itérons vers l’avant, il s’agit de l’élément situé juste avant l’itérateur ; si nous itérons vers l’arrière, il s’agit de l’élément situé juste après l’itérateur.

La fonction next() renvoie une référence non constante à l’élément de la liste. Pour les opérations simples, nous n’avons même pas besoin de setValue() :

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

Comme mentionné ci-dessus, les classes d’itérateurs de ` QSet` possèdent exactement la même API que celles de ` QList`. Nous allons maintenant nous intéresser à ` QMapIterator`, qui est quelque peu différente car elle itère sur des paires (clé, valeur).

Tout comme QListIterator, QMapIterator fournit les méthodes toFront(), toBack(), hasNext(), next(), peekNext(), hasPrevious(), previous() et peekPrevious(). Les composants « clé » et « valeur » sont extraits en appelant les méthodes key() et value() sur l’objet renvoyé par next(), peekNext(), previous() ou peekPrevious().

L'exemple suivant supprime toutes les paires (capitale, pays) dont le nom de la capitale se termine par « City » :

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 fournit également les fonctions ` key()` et ` value()`, qui opèrent directement sur l’itérateur et renvoient la clé et la valeur du dernier élément que l’itérateur a dépassé. Par exemple, le code suivant copie le contenu d’un ` QMap ` dans un ` 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());
}

Si l’on souhaite parcourir tous les éléments ayant la même valeur, on peut utiliser findNext() ou findPrevious(). Voici un exemple où l’on supprime tous les éléments ayant une valeur particulière :

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