Structures de données IFT-2000 Abder Alikacem La librairie STL du C++ Département dinformatique et de génie logiciel Édition Septembre 2009

Standard Template Library Utilisation des STL lib « list » lib « string» lib « stack» lib « algorithm » lib « queue» Concept de conteneur Adaptateur « priority_queue» lib « vector » lib « set » lib « deque» lib « multiset » Plan

Standard Template Library Utilisation des STL Développée par Alexander Stepanov et Meng Lee chez HP Sont dans le domaine public. Contiennent: les E/S, les chaînes, les conteneurs, les algorithmes les facilités numériques, les nombres complexes, la localisation et des utilitaires généraux.

Standard Template Library Utilisation des STL Le standard C++ prévoit 32 en-têtes de bibliothèques C++.

Standard Template Library Utilisation des STL Le standard C++ prévoit 18 en-têtes de bibliothèques C. Remarque: on peut écrire #include : espace de nommage « std » ou #include : pas d espace de nommage

Standard Template Library Utilisation des STL Exercice Compilez les codes suivant avec votre compilateur et concluez! #include int main() { cout << "hello world"<< endl; return 0; } #include using namespace std; int main() { cout << "hello world"<< endl; return 0; }

Standard Template Library #include using namespace std; string s1; string s2( hello world ); int i = s2.length(); int j = s2.size(); string s3 = s2.substr(int pos, int len); s2.insert(int pos, char *txt); Lib « string » Création dobjets Longueur Extraction de sous-chaîne Insertion

Standard Template Library #include using namespace std; s2.replace(int pos, int len, char *txt); string s4 = s2 + s3; s4 += s1; s4 += hello world s4.erase(int pos, int len); if (s4.empty()) {…} Lib « string » Remplacer des caractères Concaténer Supprimer Chaîne vide ?

Standard Template Library #include using namespace std; if (s1>s2) {…} cout << s2[2] << endl; char * Cstr = s2.c_str(); Lib « string » comparaison Indexation Accéder au char * à la C

Standard Template Library #include using namespace std; int max_size = s1.max_size(); int i = s2.capacity(); s2.resize(int new_size, char fill = 0); s2.reserve(int size); Lib « string » Taille max sur le système Quelle taille mémoire Effectivement utilisée? Retailler Réserve de la place

Standard Template Library #include using namespace std; size_t i = s1.find(char *txt); size_t i = s1.find(char *txt, int pos); size_t i = s1.rfind(char *txt); size_t i = s1.rfind(char *txt, int pos); if (i == s1.npos) {…} Lib « string » Recherche Recherche « reverse » Échec dune recherche ?

Standard Template Library #include using namespace std; size_t i = s1.find_first_of(char *txt); size_t i = s1.find_last_of(char *txt); size_t i = s1.find_first_not_of(char *txt); size_t i = s1.find_last_not_of(char *txt); Lib « string » Recherche parmi Recherche dernier parmi Recherche premier hors Recherche dernier hors

Standard Template Library #include using namespace std; string s; cin >> s; string s = hello world cout << s << endl; Lib « string » Entrée Sortie

Standard Template Library #include using namespace std; string:: const_iterator … string::iterator … Lib « string » Itérateur constant Itérateur « normal » string s = "hello world"; cout << s << endl; for(string::iterator s_it = s.begin(); s_it != s.end(); s_it++) { *s_it = (char) toupper(*s_it); } cout << s << endl;

Standard Template Library En cas derreur sur la position dun caractère, la méthode appelée génère une exception « out_of_range ». Nous verrons les exceptions un peu plus loin!

Standard Template Library Lib « algorithm » Tri de tableaux par valeurs croissantes Fonctionne si le type T possède lopérateur « < « #include using namespace std; sort(adresse 1 er élément de type T, adresse fin de liste de type T); const int N = 10; int tab[N]; sort (&tab[0], &tab[N]);

Standard Template Library Lib « algorithm » Tri de tableaux avec fonction de « tri » #include using namespace std; sort(adresse 1 er élément de type T, adresse fin de liste de type T, comparaison ); const int N = 10; int tab[N]; inline bool compSup(int i, int j) { return i > j;} sort (&tab[0], &tab[N], compSup);

Standard Template Library Lib « algorithm » Mélange de tableaux (linverse du tri) #include using namespace std; random_shuffle(adresse 1 er élément de type T, adresse fin de liste de type T ); const int N = 10; int tab[N]; sort (&tab[0], &tab[N]); random_shuffle(&tab[0], &tab[N]);

Standard Template Library Lib « algorithm » Tri partiel de tableaux #include using namespace std; partial_sort(adresse 1 er élément, adresse arrêt, adresse fin); partial_sort(adresse 1 er élément, adresse arrêt, adresse fin, comparaison); Sarrête dès que [1 er …arrêt[ est trié const int N = 10; int tab[N]; inline bool compSup(int i, int j) { return i > j;} partial_sort(&tab[0], &tab[5], &tab[N], compSup);

Standard Template Library Lib « algorithm » Copie de tableaux #include using namespace std; copy(adresse 1 er source, adresse arrêt source, adresse 1 er destination); const int N = 10; int tab[N], tab2[N]; copy(&tab[0], &tab[N], &tab2[0]);

Standard Template Library Lib « algorithm » Partitionnement de tableaux #include using namespace std; partition(adresse 1 er, adresse arrêt, critère); const int N = 10; int tab[N]; inline positive (int i) { return i>0;} partition(&tab[0], &tab[N], positive);

Standard Template Library Lib « algorithm » Rotation gauche de tableaux #include using namespace std; rotate(adresse 1 er, adresse remplaçant, adresse arrêt); const int N = 10; int tab[N]; rotate(&tab[0], &tab[2], &tab[N]); // « deux pas à gauche »

Standard Template Library Lib « algorithm » Remplissage constant de tableaux #include using namespace std; fill(adresse 1 er, adresse arrêt, valeur de type T); const int N = 10; int tab[N]; fill(&tab[0], &tab[N], 10); // remplir avec des 10

Standard Template Library Lib « algorithm » Remplacement dune valeur par une autre dans un tableau #include using namespace std; replace(adresse 1 er, adresse arrêt, valeur recherché, nouvelle valeur); const int N = 10; int tab[N]; replace(&tab[0], &tab[N], 10, 20); // remplacer des 10 par des 20

Standard Template Library Lib « algorithm » Remplacement des éléments avec fonction de calcul #include using namespace std; generate(adresse 1 er, adresse arrêt, fonction de calcul); const int N = 10; int tab[N]; int paire() {static int start = 0; start += 2; return start -2;} generate(&tab[0], &tab[N], paire); // remplissage avec des //nombres paires croissants

Standard Template Library Lib « algorithm » Renverser lordre des éléments dun tableau #include using namespace std; reverse(adresse 1 er, adresse arrêt); const int N = 10; int tab[N]; reverse(&tab[0], &tab[N]);

Standard Template Library Lib « algorithm » Fusionner deux tableaux #include using namespace std; merge(adr 1 er src1, adr arrêt src1, adr 1 er src2, adr arrêt src2, adr 1 er dest); const int N = 10; int tab[N], tab2[N], TAB [2*N]; merge(&tab[0], &tab[N], &tab2[0], &tab2[N], &TAB[0]);

Standard Template Library Lib « algorithm » Réduire un tableau en enlevant les doublons successifs #include using namespace std; nouvelle adr arrêt = unique (adr 1 er, adr arrêt); const int N = 10; int tab[N], tab2[N], TAB [2*N]; merge(&tab[0], &tab[N], &tab2[0], &tab2[N], &TAB[0]); sort (&TAB[0], &TAB[2*N]); int * newstop = unique(&TAB[0],&TAB[2*N]);

Standard Template Library Lib « algorithm » Parcours séquentiel dun tableau avec calcul #include using namespace std; transform (adr 1 er, adr arrêt, adr 1 er dest, calcul); const int N = 10; int tab[N], tab2[N]; inline int add1(int i) { return i+1;} // ajout de 1 à chaque élément transform(&tab[0], &tab[N], &tab2[0], add1);

Standard Template Library Lib « algorithm » Parcours séquentiel de deux tableaux avec calcul #include using namespace std; transform (adr 1 er src1, adr arrêt src1, adr 1 er src2, adr 1 er dest, calcul); const int N = 10; int tab[N], tab2[N], sum[N]; inline int add(int i, int j) { return i+j;} // faire la somme transform(&tab[0], &tab[N], &tab2[0], &sum[0], add);

Standard Template Library Lib « algorithm » Échanger le contenu de deux tableaux #include using namespace std; swap_ranges (adr 1 er src1, adr arrêt src1, adr 1 er src2); const int N = 10; int tab[N], tab2[N]; swap_ranges(&tab[0], &tab[N], &tab2[0]);

Standard Template Library Lib « algorithm » Rechercher un élément dans un tableau #include using namespace std; find (adr 1 er, adr arrêt, valeur de recherche); Renvoie la position si trouvé, sinon adr arrêt const int N = 10; int tab[N]; // rechercher 0 find(&tab[0], &tab[N], 0);

Standard Template Library Lib « algorithm » Rechercher par fonction dans un tableau Renvoie la position si trouvé, sinon adr arrêt #include using namespace std; find_if (adr 1 er, adr arrêt, fonction de recherche); const int N = 10; int tab[N]; bool zero (int i) {return i == 0;} find_if(&tab[0], &tab[N], zero);

Standard Template Library Lib « algorithm » Rechercher deux valeurs adjacentes identiques dans un tableau Renvoie la position si trouvé, sinon adr arrêt #include using namespace std; adjacent_find (adr 1 er, adr arrêt); const int N = 10; int tab[N]; adjacent_find(&tab[0], &tab[N]);

Standard Template Library Lib « algorithm » Rechercher deux valeurs adjacentes ayant une propriété Renvoie la position si trouvé, sinon adr arrêt #include using namespace std; adjacent_find (adr 1 er, adr arrêt, propriété); const int N = 10; int tab[N]; bool egales (int i, int j) {return i == j;} adjacent_find(&tab[0], &tab[N], egales);

Standard Template Library Lib « algorithm » Compter le nombre doccurrence dune valeur Renvoie le nombre doccurences #include using namespace std; int count(adr 1 er, adr arrêt, valeur de recherche); const int N = 10; int tab[N]; //nombres de valeurs nulles int n = count(&tab[0], &tab[N], 0);

Standard Template Library Lib « algorithm » Compter le nombre doccurrence ayant une propriété Renvoie le nombre doccurences #include using namespace std; int count_if(adr 1 er, adr arrêt, fonction de recherche); const int N = 10; int tab[N]; bool nulle (int i) {return i == 0;} //nombres de valeurs nulles int n = count(&tab[0], &tab[N], nulle);

Standard Template Library Lib « algorithm » Un « for » de plus… #include using namespace std; for_each(adr 1 er, adr arrêt, fonction de calcul); const int N = 10; int tab[N]; void affiche (int i) {cout << i << endl;} //parcours et affiche for_each(&tab[0], &tab[N], affiche);

Standard Template Library Lib « algorithm » Un tableau A est il inclus dans un tableau B? #include using namespace std; bool includes (adr 1 er B, adr arrêt B, adr 1 er A, adr arrêt A); const int N = 10; int A[N], B[2*N]; //A est-il inclus dans B bool b = inlcudes(&B[0], &B[2*N], &A[0], &A[N]);

Standard Template Library Lib « algorithm » C = Union de A et B #include using namespace std; adr arrêt dst = set_union (adr 1 er A, adr arrêt A, adr 1 er B, adr arrêt B, adr 1 er C); const int N = 10; int A[N], B [N], C[2*N]; // C = A union B int * last = set_union(&A[0], &A[N], &B[0], &B[N], &C[0]);

Standard Template Library Lib « algorithm » Intersection de A et B #include using namespace std; adr arrêt dst=set_intersection(adr 1 er A,adr arrêt A,adr 1 er B,adr arrêt B,adr 1 er C); const int N = 10; int A[N], B [N], C[N]; // C = A intersection B int * last = set_intersection(&A[0], &A[N], &B[0], &B[N], &C[0]);

Standard Template Library Lib « algorithm » Différence de A et B (A-B) #include using namespace std; adr arrêt dst=set_difference(adr 1 er A,adr arrêt A,adr 1 er B,adr arrêt B); const int N = 10; int A[N], B [N], C[N]; // C = A - B int * last = set_différence(&A[0], &A[N], &B[0], &B[N], &C[0]);

Standard Template Library Lib « algorithm » Différence symétrique A et B ((A union B) – (A intersection B)) #include using namespace std; adr arrêt dst=set_symmetric_difference(adr 1 er A, adr arrêt A, …); const int N = 10; int A[N], B [N], C[N]; // C = (A B) – (A B) int * last = set_symmetric_difference(&A[0], &A[N], &B[0], &B[N], &C[0]);

Standard Template Library Concept de conteneur Les conteneurs sont des structures de données permettant de ranger en mémoire des ensembles de valeurs « copie constructibles ». Le type tableau est un « conteneur », mais il y en a dautres en C++ qui sont beaucoup plus génériques 1.Conteneurs séquentiels: vector, deque, list 2.Conteneurs associatifs: set, multiset, map, multimap

Standard Template Library #include using namespace std; const int N = 10; vector t(N), T(N,0); int i = 5; int j = t[i]; sort(&t[0], &t[N]); vector ::interator it; for(it = t.begin(); it!=t.end(); it++) {…} Lib « vector » vector est générique Déclaration Indexation itérateurs

Standard Template Library #include using namespace std; t.resize(x,y); vector u(2*N, 0); u=t; t.clear(); int i = 1; t.insert(t.end(), i); Lib « vector » Taille dynamique copie Effacer le contenu après t.clear() == 0 Insérer une valeur

Standard Template Library #include using namespace std; sort(t.begin(), t.end()); t.swap(T) t.erase(t.begin()); vector ::reverse_iterator rit; for(rit=t.rbegin(); rit!=t.rend(); rit++) {…} Lib « vector » +itérateur Permuter Supprimer un élément Itérateur inverse

Standard Template Library #include using namespace std; int i = t.front(); int i = t.back(); t.pop_back(); t.pop_front(); //NON int i =1; t.push_back(i); t.push_front(i); //NON Lib « vector » Accès au premier élément Accès au dernier élément Supprimer fin de liste Insérer en fin de liste

Standard Template Library #include using namespace std; int size = t.size(); int max_size = t.max_size(); int i =10; int j = t.at(i); Lib « vector » Longueur de la liste Longueur max dépend du système Indexation + contrôle dynamique des bornes

Standard Template Library En cas derreur sur la position dun élément, la méthode appelée génère une exception « out of range ». Nous verrons les exceptions plus loin!

Standard Template Library #include using namespace std; deque d; d.push_front(0); d.pop_front(); Lib « deque » deque est générique Toutes les méthodes de sont utilisables + Insérer en tête Supprimer en tête

Standard Template Library #include using namespace std; Lib « list » list est générique Ne supporte que les itérateurs bidirectionnels. Pas daccès direct. [] et at() ne sont pas supportés par cette classe. Les algorithmes qui nécessitent laccès direct ne sont pas applicables. Par exemple, vector::sort(). De nouvelles méthodes et des implémentations spécifiques de certains algorithmes.

Standard Template Library #include using namespace std; list d; d.sort(); list e; d.merge(e); d.unique(); d.reverse(); d.remove(0); Lib « list » list est générique sort() merge() unique() reverse() remove()

Standard Template Library #include using namespace std; d.splice(d.begin(), e); Lib « list » list est générique Combiner 2 listes Cela ajoute la liste e avant lélément pointé par litérateur. Après splice(), e est vide.

Standard Template Library #include using namespace std; Lib « stack » stack est générique Ne peut être instancié quà partir dun des conteneurs suivants:, ou. Il suffit que le conteneur supporte les fonctions : back(), push_back() et pop_back(). Cest une PILE!

Standard Template Library #include using namespace std; stack > s; s.push(1); s.pop(); int n = s.size(); Lib « stack » stack est générique Déclaration (pile dentiers) Empiler Dépiler Taille de la pile

Standard Template Library #include using namespace std; if(s.empty()){…} int i = s.top(); Lib « stack » stack est générique Pile vide? Sommet de la pile

Standard Template Library #include using namespace std; Lib « queue » queue est générique Ne peut être instancié quà partir dun des conteneurs suivants: ou Cest une FIFO!

Standard Template Library #include using namespace std; queue > f; int n =f.size(); f.push(10); f.pop(); Lib « queue » queue est générique Déclaration Taille Ajouter en tête Supprimer en queue

Standard Template Library #include using namespace std; int tete =f.front(); int fin = f.back(); Lib « queue » queue est générique Tête de la file Fin de la file

Standard Template Library #include using namespace std; Lib « priority_queue » priority_queue est générique Cest une liste avec un critère de tri automatique lors de linserstion. Le « plus grand » élément est en tête de liste. Ne peut être instancié quà partir des conteneurs suivants: ou A besoin dun objet de type « fonction de comparaison »

Standard Template Library #include using namespace std; priority_queue, greater > q; if(q.empty()) {…} int size = q.size(); Lib « priority_queue » priority_queue est générique Création File vide? Taille de la file

Standard Template Library #include using namespace std; int i = 10; q.push(i); q.pop(); int i = q.top(); Lib « priority_queue » priority_queue est générique Ajouter un élément Supprimer la tête (le + grand) Obtenir tête de liste

Standard Template Library #include using namespace std; Lib « set » set est générique Cest un conteneur associatif. Il permet de stocker des objet ayant une clé daccès associatif unique. Il peut être parcouru dans les deux sens. Les objets sont classés selon une relation dordre sur les clés.

Standard Template Library #include using namespace std; set > s; set >::iterator it; set >::const_iterator cit; for(it=s.begin(); it!=s.end(); it++) {…} int i = 22; s.insert(i); Lib « set » set est générique Création Itérateur Insertion

Standard Template Library #include using namespace std; pair > ::iterator, bool> p; p = s.insert(22); if(p.second) {…} //erreur s.erase(22); set >::iterator it; … s.erase(it); Lib « set » set est générique Détection insertion double Éliminer un élément daprès sa valeur Éliminer un élément daprès sa position

Standard Template Library #include using namespace std; set > ::iterator it; it = s.find(22); if(it != s.end()) {…} //trouvé set > ::iterator it; it = s.lower_bound(22); set >::iterator it; it = s.upper_bound(22); Lib « set » set est générique Recherche dune valeur Recherche de la première valeur supérieure ou égale Recherche de la première valeur supérieur

Standard Template Library #include using namespace std; multiset > m; int n = m.erase(22); Lib « set » multiset est générique Comme « set » mais les clés peuvent apparaître plusieurs fois. création Erase renvoie le nombre dobjets retirés

Standard Template Library Lib « map » est un conteneur associatif quasiment identique au « set » à ceci sauf que la clé fait partie de lélément stocké dans le « map ». Les fonctions définies pour les « set » sappliquent également aux « map ».

Standard Template Library #include using namespace std; class A { public :int i; float f; A(int j, float g): i(j), f(g) {} }; typedef map > mapA; typedef mapA::value_type mapA_item; #include `int a =1; float b =1.0; mapA_item mAi = make_pair(a, A(a,b)); int i = mAi.first; A aa = mAi.second; Lib « map » Création Value_type est une « paire »

Standard Template Library #include using namespace std; mapA mA; mA.insert(mAi); mA[1].f +=2.0; Lib « map » Accès direct à un élément

Standard Template Library #include using namespace std; Lib « multimap » Le « multimap » est au « map » ce que le « multiset » sont au « set ».

Standard Template Library Objets de type fonction #include using namespace std; Les objets fonctions sont définis dans la bibliothèque « functional » Tout objet fonction doit fournir une implémentation de loprateur operator(), cest-à-dire une surdéfinition de lappel de fonction. Cest un concept qui permet de remplacer les pointeurs sur des fonctions Par des noms de classes qui implémentent lopérateur operator ().

Standard Template Library Objets de type fonction Comparaisons equal_to, not_equal_to, greater, less, greater_equal, less_equal Opérations logiques logical_and, logical_or, logical_not Négateurs unary_negate, binary_negate, not1, not2 Lieurs binder1st, bind1st, binder2nd, bind2nd Adaptateurs pointer_to_unary_function, pointer_to_binary_function,... Opérations arithmétiques plus, minus, multiplies, divides, modulus

Standard Template Library Objets de type fonction #include multiplies my_mult; int i = 2; int j = 4; cout << my_mult(i,j) << endl; template class my_mult { public: T operator() (T a, T b){ return a*b; } }; float i = 2.0; float j = 4.0; cout (i,j) << endl;

Standard Template Library Lib « valarray » Création Taille du valarray Parcours #include using namespace std; const int nb_elem = 10; valarray v(nb_elem); cout << v.size() << endl; for(int i = 0; i < v.size(); i+++ v[i] = i*1.5;

Standard Template Library Lib « valarray » Minimum et maximum Somme des éléments #include using namespace std; cout << v.min() << endl; cout << v.max() << endl; cout << v.sum() << endl;

Standard Template Library Lib « valarray » Affichage #include using namespace std; template ostream& operator & v) { for(int i=0;i<v.size();i++)o<<v[i]<< ; return (o << endl); } cout << v<< endl;

Standard Template Library Lib « valarray » Décalage gauche et droit Rotations gauche et droites Apply #include using namespace std; v.shift(2); cout << v << endl; v.shift(-2); cout << v << endl; v.cshift(2); cout << v << endl; v.cshift(-2); cout << v << endl; double array(double i) {return i*i;} v.apply(carre); cout << v << endl;

Standard Template Library Lib « valarray » Retailler Cest comme un « vector » #include using namespace std; v.resize(5); cout << v << endl; v.resize(10, 7); cout << v <<endl;

Standard Template Library Lib « valarray » Nouvelles opérations!!! #include using namespace std; const N =10; valarray} v1(N), v2(N), v3(N); for(int i=0; i<v1.size(); i++)v1[i]=i*1.5; for(int i=0; i<v2.size(); i++)v2[i]=i/3; cout << v1 << endl; cout << v2 << endl; v3 = v1+v2; cout << v3 << endl;

Standard Template Library Lib « valarray » Essayez les opérations arithmétiques #include using namespace std; v3 = v1+v2; cout << v3 << endl; v3 = v1 – v2; cout << v3 << endl; v3 = v1*v2; cout << v3 << endl; v3 = v1/v2; cout << v3 << endl;

Standard Template Library Lib « valarray » Essayez les opérations logiques #include using namespace std; v3 = v1 < v2; cout << v3 << endl; v3 = v1 >= v2; cout << v3 << endl; v3 = ~v3; cout << v3 << endl;

Standard Template Library Lib « valarray » Essayez les fonctions mathématiques #include using namespace std; v3 = sqrt(v1); cout << v3 << endl; v3 = pow(v1,2); cout << v3 << endl;

Standard Template Library Lib « valarray » la nouveauté!!! Indices Objet de type « slice_array » Initialisation de la tranche #include using namespace std; slice(int départ, int taille, int pas); v1[slice(0,5,2)] // position paires v1[slice(1,5,2)] // position impaires v1[slice(0,5,2)] = 0; //position paire v1[slice(1,5,2)] = 1; // positions impaires

Standard Template Library Lib « valarray » la nouveauté!!! Lopérateur daffectation est ainsi défini Affectation! #include using namespace std; slice_array = valarray; v1[slice(0,5,2)] = static_cast (v1[slice(1,5,2)]);

Standard Template Library Les itérateurs À sens unique Bidirectionnels Accès direct En avant seulement En avant et en arrière Idem + indexation

Standard Template Library Les itérateurs Avancer à lélément suivant Reculer à lélément précédent Accès direct it++ ou ++it it– ou –it it + n ou n + it it - n it +=n it -= n it[n] it – jt (distance) i<j

Standard Template Library Les itérateurs Déclarations iterator const iterator reverse_iterator const reverse_iterator

Standard Template Library Les itérateurs const int N = 10; vector t(N); vector ::iterator it; vector ::const_iterator cit; vector ::reverse_iterator rit; vector ::const_reverse_iterator crit; for(it=t.begin(); it!=t.end(); ++it) *it = rand() % 100; for(cit=t.begin(); cit!=t.end(); ++cit) cout << *cit << ; cout << endl; for(rit=t.rbegin(); rit!=t.rend(); ++rit) *rit *= 2; for(crit=t.rbegin(); crit!=t.rend(); ++crit) cout << *crit << ; cout << endl;