Itérateurs

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy — leçon 72 sur 104.

Les itérateurs sont des objets qui servent de pont entre les conteneurs et les algorithmes. Ils offrent une manière uniforme d'accéder aux éléments de n'importe quel conteneur, indépendamment de la façon dont ce conteneur stocke ses données en interne. Considérez un itérateur comme un pointeur généralisé qui sait comment parcourir un conteneur.

Chaque conteneur STL fournit les méthodes begin() et end(). L'itérateur begin() pointe vers le premier élément, tandis que end() pointe juste après le dernier élément — une sentinelle qui marque l'endroit où s'arrêter :

#include <vector>
#include <iostream>

int main() {
    std::vector<int> nums = {10, 20, 30};
    
    for (std::vector<int>::iterator it = nums.begin(); it != nums.end(); ++it) {
        std::cout << *it << " ";  // Déréférencer pour obtenir la valeur
    }
    // Sortie : 10 20 30
}

Le mot-clé auto simplifie considérablement les déclarations d'itérateurs :

for (auto it = nums.begin(); it != nums.end(); ++it) {
    *it *= 2;  // Modifier les éléments via l'itérateur
}
// nums est maintenant {20, 40, 60}

Les itérateurs sont classés en différentes catégories selon leurs capacités. Les itérateurs à accès aléatoire (comme ceux de vector) prennent en charge les opérations arithmétiques telles que it + 3 ou it1 - it2.

Les itérateurs bidirectionnels (provenant de list, map) peuvent se déplacer vers l'avant et vers l'arrière avec ++ et --. Les itérateurs unidirectionnels ne peuvent se déplacer que dans une seule direction.

Pour le parcours inverse, utilisez rbegin() et rend() :

for (auto rit = nums.rbegin(); rit != nums.rend(); ++rit) {
    std::cout << *rit << " ";  // Affiche dans l'ordre inverse
}

Défi

Facile

Construisons un système de suivi d'inventaire qui utilise des itérateurs pour parcourir et manipuler des collections d'articles. Vous vous entraînerez à utiliser différents types d'itérateurs pour naviguer dans les données de diverses manières.

Vous organiserez votre code sur deux fichiers :

Inventory.h : Définissez une classe Inventory qui gère une collection de quantités d'articles stockées dans un std::vector<int>.
Votre classe doit fournir ces méthodes :
- addItem(int quantity) — ajoute une quantité d'article à l'inventaire
- printForward() — utilise des itérateurs avec begin() et end() pour afficher toutes les quantités séparées par des espaces, suivies d'un saut de ligne
- printReverse() — utilise des itérateurs inverses avec rbegin() et rend() pour afficher toutes les quantités dans l'ordre inverse, séparées par des espaces, suivies d'un saut de ligne
- doubleAll() — utilise des itérateurs pour parcourir le vecteur et doubler chaque quantité sur place
- getTotal() — utilise des itérateurs pour calculer et retourner la somme de toutes les quantités
Utilisez le mot-clé auto pour vos déclarations d'itérateurs afin de garder le code propre.
main.cpp : Lit quatre entrées entières (chacune sur une ligne séparée) représentant les quantités d'articles.
Créez un Inventory et ajoutez les quatre quantités. Ensuite, démontrez l'utilisation des itérateurs en :
1. Affichant Forward: suivi de l'appel à printForward()
2. Affichant Reverse: suivi de l'appel à printReverse()
3. Affichant Total: <sum> en utilisant getTotal()
4. Appelant doubleAll() pour modifier les quantités
5. Affichant After doubling: suivi de l'appel à printForward()
6. Affichant New total: <sum> en utilisant getTotal()

Par exemple, avec les entrées 10, 25, 15, et 30 :

Forward: 10 25 15 30 
Reverse: 30 15 25 10 
Total: 80
After doubling: 20 50 30 60 
New total: 160

Ce défi vous permet de pratiquer à la fois la lecture d'éléments via des itérateurs (pour l'affichage et la somme) et la modification d'éléments via des itérateurs (pour le doublage). Vous verrez également comment les itérateurs inverses facilitent le parcours à l'envers sans aucune manipulation d'index.

Aide-mémoire

Les itérateurs sont des objets qui fournissent un moyen uniforme d'accéder aux éléments dans des conteneurs. Ils agissent comme des pointeurs généralisés qui savent comment se déplacer à travers un conteneur.

Chaque conteneur STL fournit des méthodes begin() et end(). L'itérateur begin() pointe vers le premier élément, tandis que end() pointe juste après le dernier élément :

std::vector<int> nums = {10, 20, 30};

for (std::vector<int>::iterator it = nums.begin(); it != nums.end(); ++it) {
    std::cout << *it << " ";  // Déréférencer pour obtenir la valeur
}

Utilisez le mot-clé auto pour simplifier les déclarations d'itérateurs :

for (auto it = nums.begin(); it != nums.end(); ++it) {
    *it *= 2;  // Modifier les éléments via l'itérateur
}

Catégories d'itérateurs basées sur leurs capacités :

Les itérateurs à accès aléatoire (par exemple, vector) prennent en charge les opérations arithmétiques comme it + 3 ou it1 - it2
Les itérateurs bidirectionnels (par exemple, list, map) peuvent se déplacer vers l'avant et vers l'arrière avec ++ et --
Les itérateurs vers l'avant ne peuvent se déplacer que dans une seule direction

Pour un parcours inverse, utilisez rbegin() et rend() :

for (auto rit = nums.rbegin(); rit != nums.rend(); ++rit) {
    std::cout << *rit << " ";  // Affiche dans l'ordre inverse
}

Essayez vous-même

#include <iostream>
#include "Inventory.h"

using namespace std;

int main() {
    // Lire quatre entrées entières
    int q1, q2, q3, q4;
    cin >> q1;
    cin >> q2;
    cin >> q3;
    cin >> q4;

    // TODO: Créer un objet Inventory

    // TODO: Ajouter les quatre quantités à l'inventaire

    // TODO: Imprimer "Forward: " puis appeler printForward()

    // TODO: Imprimer "Reverse: " puis appeler printReverse()

    // TODO: Imprimer "Total: " suivi du résultat de getTotal()

    // TODO: Appeler doubleAll() pour modifier les quantités

    // TODO: Imprimer "After doubling: " puis appeler printForward()

    // TODO: Imprimer "New total: " suivi du résultat de getTotal()

    return 0;
}