Page principale | Pages associées

Les Itérateurs

Les itérateurs sont, on l'a vu dans le tutorial précédent, essentiel pour utiliser les algorithmes. Ceux que nous avons vu jusqu'à maintenant étaient mis à disposition par les conteneurs eux-mêmes. Mais il y a aussi les itérateurs d'insertions et les itérateurs de flux. Les premiers se 'branchent' sur les conteneurs, les seconds permettent d'utiliser des flux (stream). Ils permettent ainsi d'utiliser les conteneurs et les flux pour des itérateurs de sortie (ou d'entrée).

Començons par les itérateur d'insertions. Il en existe trois prédéfinis qui peuvent servir d'itérateur de sortie :

Les itérateurs de flux permettent quant à eux d'être branchés sur les flux afin d'utiliser ces flux dans les algorithmes de la STL. Il en existe deux :

Il y a deux programmes pour les exemples. Le premier sur les itérateurs d'insertion et le second (iter7.cpp) sur les itérateurs de flux.

#include <iostream> #include <vector> #include <list> #include <set> #include <algorithm> #include <iterator>
le fichier à inclure pour utiliser les itérateurs prédéfinis

using namespace std;
le décor est planté

// Fonction permettant d'afficher un entier void afficher( int i ) { cout << i << ' '; } // ----- programme principal ----- int main() { // On déclare juste un tableau const int aInt_size = 10; int aInt[aInt_size] = { 8, 4, 2, 3, 6, 10, 9, 5, 1, 7 }; // --------------------- VECTOR ----------------------------------- { // Création d'un vecteur à partir du tableau vector<int> vInt; copy( aInt, aInt+aInt_size, back_inserter( vInt ) );
copy permet de copier (original, non?) les éléments de aInt vers la sortie, ici un back_inserter sur le vecteur vInt, ce qui aura pour effet ajouter par push_back les éléments à vInt

// Affichage du vecteur cout << "Vecteur : " << endl; for_each( vInt.begin(), vInt.end(), afficher ); cout << endl; } // --------------------- LIST ----------------------------------- { // Création d'une liste à partir du tableau list<int> lInt; copy( aInt, aInt+aInt_size, back_inserter( lInt ) );
Les éléments de aInt sont ajoutés à la liste en utilisant le push_back

// Affichage de la liste cout << "Liste : " << endl; for_each( lInt.begin(), lInt.end(), afficher ); cout << endl; // On vide la liste lInt.clear(); // On recopie le tableau dans la liste à l'envers copy( aInt, aInt+aInt_size, front_inserter( lInt ) );
Les éléments de aInt sont ajoutés à la liste en utilisant le push_front

// Affichage de la liste cout << "Liste inversée : " << endl; for_each( lInt.begin(), lInt.end(), afficher ); cout << endl; } // --------------------- SET ----------------------------------- { // Création d'un set à partir du tableau set<int> sInt; copy( aInt, aInt+aInt_size, inserter( sInt, sInt.end() ) );
Les éléments de aInt sont insérés dans le set en utilisant la méthode insert( position ) du set

// Affichage du vecteur cout << "Ensemble : " << endl; for_each( sInt.begin(), sInt.end(), afficher ); cout << endl; // L'insertion dans le set à automatique triée les éléments // du set qui sont donc affichés dans l'ordre } }

En résumé, les itérateurs d'insertions peuvent être utilisés pour les algorithmes nécessitant un itérateur de sortie.

La suite...


Le source complet :
#include <iostream> #include <vector> #include <list> #include <set> #include <algorithm> #include <iterator> using namespace std; // Fonction permettant d'afficher un entier void afficher( int i ) { cout << i << ' '; } // ----- programme principal ----- int main() { // On déclare juste un tableau const int aInt_size = 10; int aInt[aInt_size] = { 8, 4, 2, 3, 6, 10, 9, 5, 1, 7 }; // --------------------- VECTOR ----------------------------------- { // Création d'un vecteur à partir du tableau vector<int> vInt; copy( aInt, aInt+aInt_size, back_inserter( vInt ) ); // Affichage du vecteur cout << "Vecteur : " << endl; for_each( vInt.begin(), vInt.end(), afficher ); cout << endl; } // --------------------- LIST ----------------------------------- { // Création d'une liste à partir du tableau list<int> lInt; copy( aInt, aInt+aInt_size, back_inserter( lInt ) ); // Affichage de la liste cout << "Liste : " << endl; for_each( lInt.begin(), lInt.end(), afficher ); cout << endl; // On vide la liste lInt.clear(); // On recopie le tableau dans la liste à l'envers copy( aInt, aInt+aInt_size, front_inserter( lInt ) ); // Affichage de la liste cout << "Liste inversée : " << endl; for_each( lInt.begin(), lInt.end(), afficher ); cout << endl; } // --------------------- SET ----------------------------------- { // Création d'un set à partir du tableau set<int> sInt; copy( aInt, aInt+aInt_size, inserter( sInt, sInt.end() ) ); // Affichage du vecteur cout << "Ensemble : " << endl; for_each( sInt.begin(), sInt.end(), afficher ); cout << endl; // L'insertion dans le set à automatique triée les éléments // du set qui sont donc affichés dans l'ordre } }
00001 #include <iostream> 00002 #include <vector> 00003 #include <list> 00004 #include <set> 00005 #include <algorithm> 00006 #include <iterator> 00007 using namespace std; 00008 // Fonction permettant d'afficher un entier 00009 void afficher( int i ) { cout << i << ' '; } 00010 00011 // ----- programme principal ----- 00012 int main() 00013 { 00014 // On déclare juste un tableau 00015 const int aInt_size = 10; 00016 int aInt[aInt_size] = { 8, 4, 2, 3, 6, 10, 9, 5, 1, 7 }; 00017 00018 // --------------------- VECTOR ----------------------------------- 00019 { // Création d'un vecteur à partir du tableau 00020 vector<int> vInt; 00021 copy( aInt, aInt+aInt_size, back_inserter( vInt ) ); 00022 // Affichage du vecteur 00023 cout << "Vecteur : " << endl; 00024 for_each( vInt.begin(), vInt.end(), afficher ); 00025 cout << endl; 00026 } 00027 00028 // --------------------- LIST ----------------------------------- 00029 { // Création d'une liste à partir du tableau 00030 list<int> lInt; 00031 copy( aInt, aInt+aInt_size, back_inserter( lInt ) ); 00032 // Affichage de la liste 00033 cout << "Liste : " << endl; 00034 for_each( lInt.begin(), lInt.end(), afficher ); 00035 cout << endl; 00036 00037 // On vide la liste 00038 lInt.clear(); 00039 00040 // On recopie le tableau dans la liste à l'envers 00041 copy( aInt, aInt+aInt_size, front_inserter( lInt ) ); 00042 // Affichage de la liste 00043 cout << "Liste inversée : " << endl; 00044 for_each( lInt.begin(), lInt.end(), afficher ); 00045 cout << endl; 00046 } 00047 00048 // --------------------- SET ----------------------------------- 00049 { // Création d'un set à partir du tableau 00050 set<int> sInt; 00051 copy( aInt, aInt+aInt_size, inserter( sInt, sInt.end() ) ); 00052 // Affichage du vecteur 00053 cout << "Ensemble : " << endl; 00054 for_each( sInt.begin(), sInt.end(), afficher ); 00055 cout << endl; 00056 // L'insertion dans le set à automatique triée les éléments 00057 // du set qui sont donc affichés dans l'ordre 00058 } 00059 }

Dernière modification : Sun Jul 4 20:19:13 2004