Bibliothèque standard C++<iterator>

Dans la bibliothèque standard C++,<iterator>Le fichier d'en-tête fournit un ensemble d'outils pour parcourir les éléments des conteneurs. Les itérateurs sont l'un des concepts fondamentaux de la bibliothèque de modèles standard C++ (STL), permettant aux programmeurs d'accéder aux éléments des conteneurs de manière unifiée sans avoir à se soucier des détails d'implémentation spécifiques du conteneur.

Un itérateur est un objet qui fournit une méthode pour parcourir les éléments d'un conteneur. Un itérateur peut être vu comme un pointeur vers un élément d'un conteneur, mais il est plus flexible et plus puissant qu'un pointeur. Les itérateurs peuvent être utilisés pour accéder aux éléments d'un conteneur et les modifier, et peuvent être utilisés avec les algorithmes de la STL.

Les itérateurs sont principalement divisés en les catégories suivantes :

  1. Itérateur d'entrée: Peut uniquement effectuer des opérations de lecture unique, ne peut pas effectuer d'opérations d'écriture.
  2. Itérateur de sortie: Peut uniquement effectuer des opérations d'écriture unique, ne peut pas effectuer d'opérations de lecture.
  3. Itérateur avant: Peut effectuer des opérations de lecture et d'écriture, et peut avancer.
  4. Itérateur bidirectionnel: En plus de toutes les opérations d'un itérateur avant, il peut également reculer.
  5. Itérateur d'accès aléatoire: En plus de toutes les opérations d'un itérateur bidirectionnel, il peut également effectuer un accès aléatoire, comme accéder aux éléments par index.

Fonctions courantes (point clé)

Fonction Fonction Exemple Description
std::advance(it, n) Déplacer l'itérateur vers l'avant de n pas advance(it, 2); Modifiera l'itérateur d'origine
std::distance(a, b) Calculer la distance entre deux itérateurs distance(v.begin(), v.end()); Renvoie le nombre d'éléments
std::next(it, n) Renvoie un nouvel itérateur avancé de n pas auto it2 = next(it, 2); Recommandé, ne modifie pas la valeur d'origine
std::prev(it, n) Renvoie un nouvel itérateur reculé de n pas auto it2 = prev(it, 1); Pris en charge depuis C++11

Adaptateurs d'itérateurs (très importants)

Les adaptateurs d'itérateurs peuvent modifier le comportement des itérateurs pour les adapter à différents scénarios d'utilisation.

Adapter Fonction Exemple
std::back_inserter Insertion en queue (appel à push_back) back_inserter(vec)
std::front_inserter Insertion en tête (appel à push_front) front_inserter(list)
std::inserter Insérer à la position spécifiée inserter(vec, it)

Itérateurs de flux (une aubaine pour simplifier les E/S)

Type Fonction Exemple
std::istream_iterator Lire des données depuis le flux d'entrée istream_iterator<int>(cin)
std::ostream_iterator Écrire dans le flux de sortie ostream_iterator<int>(cout, " ")

Syntaxe des itérateurs

La syntaxe des itérateurs est généralement la suivante :

#include &lt;iterator&gt;

// 使用迭代器遍历容器
for (ContainerType::iterator it = container.begin(); it != container.end(); ++it) {
    // 访问元素 *it
}

Exemple

Voici un exemple utilisant<iterator>Fichiers d'en-tête et parcours d'itérateursstd::vectorexemple :

Exemple

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>

int main() {
    // Créer un conteneur vector et l'initialiser
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // Parcourir le vector à l'aide d'itérateurs
    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // Utilisez le mot-clé auto pour simplifier les types d'itérateurs
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // Utilisez la boucle for basée sur les plages de C++11
    for (int elem : vec) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // Utilisez back_inserter pour l'insertion automatique
    std::vector<int> v2;
    std::fill_n(std::back_inserter(v2), 3, 100);

    // Utilisez ostream_iterator pour la sortie
    std::copy(v2.begin(), v2.end(),
              std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;

    return 0;
}

Sortie :

1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 
100 100 100

Résumé

<iterator>Les fonctions principales peuvent être résumées en trois points :

  • Méthode d'accès unifiée : différents conteneurs utilisent le même ensemble de logique de parcours.
  • Découplage des conteneurs et des algorithmes : les algorithmes dépendent uniquement des itérateurs.
  • Amélioration de la réutilisabilité du code : le même morceau de code peut être appliqué à plusieurs structures de données.

Pour les débutants, il est recommandé de maîtriser en priorité les éléments suivants :

  • next / prev / distance
  • back_inserter
  • Méthode de parcours d'itérateur
autres extensions