Menu

Itérateurs dans STL

iterators stl

Essayez Notre Instrument Pour Éliminer Les Problèmes

Un aperçu complet des itérateurs dans STL.

Dans ce didacticiel, nous examinerons les détails des itérateurs, leurs types, leurs avantages et les différentes fonctions qu'ils prennent en charge.

graphe non dirigé de liste de contiguïté c ++

Qu'est-ce qu'un itérateur? En général, un itérateur est comme n'importe quel objet qui pointe vers un élément particulier dans une plage de données comme un tableau ou un conteneur. Un itérateur est comme un pointeur en C.

=> Recherchez la série complète de formations C ++ ici.

ITERATEURS EN STL

Ce que vous apprendrez:

Aperçu

Dans STL, un itérateur est un objet qui peut être utilisé pour parcourir ou parcourir les éléments du conteneur en utilisant un ensemble d'opérateurs tels que l'opérateur d'incrémentation (++) ou l'opérateur de déréférence (*).

Les itérateurs sont cruciaux dans la programmation STL car ils jouent un rôle important dans la connexion des algorithmes au conteneur en plus d'accéder et de manipuler les données stockées à l'intérieur des conteneurs.

Types d'itérateurs

En fonction de la fonctionnalité implémentée par les itérateurs, ils sont classés comme suit:

Types d

  • Itérateurs d'entrée et de sortie : Ce sont les types d'itérateurs les plus simplifiés. Ils sont particulièrement utiles dans les opérations d'entrée-sortie séquentielles contenant un seul passage.
  • Itérateurs avant : Ce sont comme des itérateurs d'entrée mais ont une direction, c'est-à-dire une direction avant dans le sens où ils peuvent être utilisés pour traverser une plage dans le sens de transfert. Lorsque les itérateurs avant ne sont pas constants, ils peuvent également être utilisés comme itérateurs de sortie. La plupart des conteneurs STL standard prennent au moins en charge les itérateurs avant.
  • Itérateurs bidirectionnels : Ils sont similaires aux itérateurs avant à la seule différence qu'ils sont bidirectionnels. Cela signifie que nous pouvons utiliser ces itérateurs bidirectionnels pour traverser la plage dans la direction avant et arrière.
  • Itérateurs à accès aléatoire : Les itérateurs à accès aléatoire sont les plus puissants parmi tous les itérateurs. Ce sont des itérateurs non séquentiels. Les itérateurs à accès aléatoire nous permettent d'accéder à n'importe quelle valeur aléatoire en appliquant un décalage à la valeur actuelle sans avoir à passer par chaque élément de manière séquentielle. Ils présentent des propriétés similaires à celles des pointeurs en C.

Une chose à noter est que tous les conteneurs STL ne prennent pas en charge tous les itérateurs. Différents conteneurs prennent en charge différents itérateurs en fonction des exigences de leur fonctionnalité.

Vous trouverez ci-dessous la liste des conteneurs qui utilisent différents itérateurs:

ConteneursItérateurs
CarteBidirectionnel
EmpilerPas d'itérateur
File d'attentePas d'itérateur
File d'attente de prioritéPas d'itérateur
ListerBidirectionnel
VecteurAccès aléatoire
etAccès aléatoire
MultimapBidirectionnel
EnsembleBidirectionnel
MultisetBidirectionnel

Avantages des itérateurs

Les itérateurs sont extrêmement utiles, en particulier lors de la programmation en utilisant différentes plages et conteneurs.

Certains des avantages de l'utilisation d'itérateurs en programmation peuvent être résumés ci-dessous:

# 1) Réutilisation du code

Tant que nous utilisons des itérateurs pour accéder aux éléments de notre programme, nous pouvons simplement changer le nom du conteneur dans notre définition d'itérateur et utiliser le reste du code de la même manière chaque fois que nous devons changer le conteneur.

Ceci est particulièrement utile dans les scénarios où nous prévoyons de remplacer un conteneur vectoriel à l'aide d'un conteneur de liste. Si à la place des itérateurs nous utilisions l'opérateur (), le code pour accéder aux éléments serait inutile lorsque nous changeons les conteneurs.

# 2) Facilité et commodité de la programmation

Les itérateurs sont livrés avec diverses fonctions intégrées qui nous aident à parcourir et à accéder au contenu du conteneur facilement et commodément.

Par exemple , nous n'avons pas besoin de continuer à vérifier la fin de la liste ou le tableau que nous devons faire en utilisant les opérateurs () et nous devons modifier le code du programme comme lorsque nous voulons ajouter des éléments, et nous devons les changer pour une boucle .

Lorsque vous utilisez des itérateurs, nous pouvons accéder directement aux fonctions begin () et end () des itérateurs sans avoir à garder un œil sur le moment où nous atteignons la fin de la liste et nous n'avons pas besoin de les changer pour une boucle.

# 3) Ajout / suppression dynamique

Tout en utilisant des itérateurs, nous pouvons facilement et dynamiquement ajouter ou supprimer les éléments dans le conteneur sans avoir à déplacer les éléments comme nous devons le faire dans les opérateurs ().

Démontrons cela avec l'exemple suivant:

#include #include using namespace std; int main() { vector vec1 = { 1, 1, 2 }; // Declaring an iterator vector::iterator i; // Inserting element for (i = vec1.begin(); i != vec1.end(); ++i) { if (i == vec1.begin()) { i = vec1.insert(i, 3); // insert 3 at the beginning of vec1 } } // contents of vec1 3 1 1 2 cout<<'Vector contents after addition'; cout<

Production:

Contenu vectoriel après ajout
3 1 1 2
Contenu du vecteur après suppression
3 1 2

Comme on le voit dans l'exemple ci-dessus, nous voyons qu'en utilisant des itérateurs, nous pouvons facilement ajouter ou supprimer des éléments d'un conteneur (vecteur dans ce cas), sans avoir à recourir à la programmation complexe des éléments de décalage et de restructuration du conteneur.

Fonctions de l'itérateur

Comme les itérateurs eux-mêmes sont des constructions intégrées, ils prennent en charge diverses opérations qui peuvent être effectuées sur des objets itérateurs. Ces opérations / fonctions nous permettent de parcourir efficacement la plage et également de manipuler les éléments à l'intérieur du conteneur.

Nous allons maintenant voir quelques opérations majeures prises en charge par les itérateurs.

  • commencer: Renvoie la première position ou la position de début de l'itérateur.
  • finir: Renvoie la dernière position ou la position «après la fin» de l’itérateur.
  • prev: Renvoie le nouvel itérateur après avoir décrémenté le nombre de positions données dans l'argument.
  • suivant: Renvoie un nouvel itérateur après avoir avancé ou incrémenté le nombre de positions données dans l'argument.
  • inserteur: Insère un élément à une position donnée dans un conteneur.
  • avance: Incrémente la position de l'itérateur au nombre spécifié donné dans l'argument.

Nous démontrerons l'utilisation de certaines de ces fonctions / opérations dans le programme suivant:

#include #include #include using namespace std; int main() { vector v = { 1, 1,2,3,5 }; // declaring iterators to a vector vector::iterator itr1 = v.begin(); vector::iterator itr2 = v.end(); auto it = next(itr1, 2); // displaying iterator position cout << 'Using next() the new iterator is at: '; cout << *it << ' '; cout << endl; auto it1 = prev(itr2, 2); // displaying iterator position cout << 'The position of new iterator using prev() is: '; cout << *it1 << ' '; cout << endl; //advance advance(itr1,3); // displaying iterator position cout << 'After advance operation,itr1 is positioned at: '; cout << *itr1 << ' '; cout << endl; return 0; }

Production:

En utilisant next (), le nouvel itérateur est à: 2
La position du nouvel itérateur utilisant prev () est: 3
Après l'opération d'avance, itr1 est positionné à: 3

En utilisant le programme ci-dessus, nous avons démontré l'utilisation de diverses opérations d'itération.

Conclusion

Nous sommes donc arrivés à la fin de ce tutoriel sur les itérateurs.

Jusqu'à présent, nous avons discuté des bases de STL, à partir de notre prochain tutoriel, nous commencerons par les conteneurs STL et leur programmation.

=> Consultez la série complète de formations GRATUITES C ++ ici.

lecture recommandée

^