Vous êtes sur la page 1sur 55

STL

Standard Template Library


Définitions

La STL est une partie importante de la bibliothèque


standard du C++
http://www.sgi.com/tech/stl/
 développée par Hewlett-Packard puis Silicon Graphics
 1994 : adoptée par le comité de standardisation du C++,
pour être intégrée au langage

STL est un ensemble de classes qui, tout en collaborant,


permettent de réaliser dans une catégorie de logiciels des
conceptions réutilisables.

Les STL :
 utilisent les templates,
 n'utilisent pas l'héritage et les fonctions virtuelles pour des
raisons d'efficacité.
La librairie standard C++
• Comme son nom l’indique cette bibliothéque
utilise fortement les templates C++ et le concet
de généricité

• Elle definit des modéles de classes , de


fonctions génériques (tableau, liste, pile…) et
des algorithmes (copie, tri, recherche…)

3
Conteneurs
Conteneurs: classes permettant de représenter les structures de
données les plus répandues telles que les vecteurs, les listes, map,
etc.
vector<int> v; // vecteur vide d'éléments de type int
vector<point> v; // vecteur vide d'éléments de type point
vector<point*> v; // vecteur vide d'éléments de type point*

Un itérateur est un objet défini généralement par la classe conteneur


concernée qui généralise la notion de pointeur.
A un instant donné, un itérateur pointe sur un élément d'un conteneur.

vector<int> v; // conteneur vide


vector<int>::iterator it; // iterateur
conteneurs
On distingue différents types de conteneurs :
Les conteneurs de séquence :
 vector : accès direct à n’importe quel élément
 list : accès séquentiel avant arrière.
 Deque : associe les 2 précédents.
Les conteneurs associatifs :
 set : recherche rapide, aucun doublon autorisé.
 multiset : recherche rapide, doublons autorisés.
 map : recherche rapide par clé
Les adaptateurs de conteneur :
 stack : pile ou LIFO : dernier entré, premier sorti.
 queue : file ou FIFO : premier entré , premier sorti.
 priority_queue : L’élément de priorité la plus grande est
toujours le premier élément sorti.
#include <algorithm > // algorithmes utiles (tri , ...)
#include <deque > // tableaux dynamiques ( extensibles a chaque extremite)
#include <functional > // objets fonctions predefinis (unary_function , ...)
#include <iterator > // iterateurs , fonctions , adaptateurs
#include <list > // listes doublement chainee
#include <map > // maps et multimaps
#include <numeric > // fonctions numeriques : accumulation , ...
#include <queue > // files
#include <set > // ensembles
#include <stack > // piles
#include <string > // chaines de caracteres
#include <utility > // divers utilitaires
#include <vector > // vecteurs
Les conteneurs de la STL ont été conçus de façon à fournir des
fonctionnalités similaires, c’est pourquoi, ils contiennent un certain nombre de
méthodes et d’opérateurs communs :
Conteneur de séquence
Méthodes communes disponibles seulement dans
les conteneurs de 1ere classe
La classe vector

vector <int> v;
vector<int>::iterator it;
it=v.begin();
La classe vector
Aux méthodes communes des classes conteneurs
s’ajoute ces méthodes spécifiques :

•push_back,

•pop_back,

• front,
• back,

• at,

• capacity.
exemple
push_back
at
Front
back
Pop_back
La classe iterator

•On peut utiliser la classe vector comme les


autres conteneurs en utilisant le mécanisme
des iterateurs

•Aux méthodes précédentes s’ajoute ces méthodes


spécifiques utilisant un iterator : insert(), erase() .
•Un itérateur est une sorte de pointeur permettant de
parcourir un conteneur

pos;  « pos » est pointeur qui va


•vector<int>::iterator
parcourir un vecteur d'entiers.
Particularités générales des itérateurs

- Si « it » est un itérateur, on peut toujours faire :


 « it++ » pour pointer l'élément suivant,
 « (*it) » est l'élément pointé,
 Comparer les itérateurs par « == » ou « != ».

Certains conteneurs permettent aussi à des itérateurs


de faire :
 « it-- » pour pointer l'élément précédent,
 « it+n » accès direct,
 « > < » des tests de comparaison,
 si « ita » et « itb » sont deux itérateurs sur le même
conteneur, et on peut atteindre « itb » de « ita » alors
l'expression « ita, itb » désigne l'intervalle [ita,itb).
Utilisation d'un itérateur
insert
erase
On peut parcourir aussi un conteneur à l'envers:
vector<int>::reverse_iterator inverse;

Il est associé dans ce cas les fonctions permettant


d'obtenir les positions dans le cas d'un parcours à
l'envers : « rbegin() » et « rend() »
Iterator
Reverse_iterator
Classe List
•C'est une liste doublement chaînée.
Chaque élément de la liste a son propre segment de mémoire, et
pointe son prédécesseur et son successeur.

Les listes ne permettent pas un accès aléatoire, c.-à-d. à un index


donné, comme le font les conteneurs « vector » et « deque ».

Pour accéder au « Nième » élément de la liste, il faut passer par les


« N-1 » prédécesseurs.

L'accès a un élément donné prend un temps linéaire nettement


supérieur que si cet élément était dans un « vector » ou « deque ».

L'avantage des listes est que l'insertion ou le retrait d'un élément se


fait rapidement. Il suffit de modifier les adresses des pointeurs des
prédécesseurs et successeurs.
list<type> v; // liste vide
list<type> v(taille); / liste de teille éléments
list<type> v(taille, valeur); // liste de taille éléments à valeur valeur
list<type> v(tranche_tableau_de_type); // liste contenant les élément
d'une tranche de tableau
list<type> v(sequence_conteneur_de_type); // liste contenant une séquence
d'éléments d'un conteneur
list<type> v(variable_list_de_type); // liste copie d'une autre liste

int t[] = {1,2,3,4,5,6,7,8,9}; // tableau contenant {1,2,3,4,5,6,7,8,9}


vector<int> v(6,3); // vecteur de 6 éléments valant
3
list<int> l1; // liste vide
list<int> l2(10); // liste de 10
list<int> l3(5,2); // liste de 5 éléments valant 2
list<int> l4(t+1, t+4); // liste de 5 élément a valeurs
prises dans t
listr<int> l5(v.begin(), v.end()); // liste a valeur prises dans une
séquence de vecteur
list<int> l6(l3); // liste copie d'une autre liste
25
list
push_front() - push_back()
- front()
- back()
insert (iterateur position, iterateur debut, itérateur fin)
- position : est un iterateur qui indique avant quel élément
insert (iterateur position, const valeur x)
erase (position); // suppression de l'élément en position désignée
erase(debut, fin);// suppression d'une séquence d'éléments
pop_front

l.clear(); // l devient vide


remove : permet de supprimer tous les éléments d’une liste
ayant une certaine valeur
remove_if : permet de supprimer tous les éléments d’une liste
satisfaisant une certaine condition .le paramètre à indiquer est
un prédicat prenant comme paramètre un élément de la liste
sort : cette fonction trie les éléments d’un tableau
- soit elle ne prend aucun parametre , l’operateur < est utilisé
- soit un prédicat de comparaison
merge: fusion de 2 listes

l.swap(p); échange l, p
Reverse : Cette fonction renverse l’ordre des éléments , les
premiers seront les derniers et les derniers seront les premiers
Splice : // transfert d'une liste dans une autre
• cette fonction est une manière plus rapide de deplacer
effacer des éléments à travers une même liste ou plusieurs

list <int> liste1;


list <int> liste2;
for (int i= 1; i<5; i++)
liste1.push_back(i);
for (int i= 20; i<25; i++)
liste2.push_back(i);

liste<int>::iterator it = liste1.begin(); //it point vers 1


it++; //it pointe vers 2

liste1.splice (it, liste2); // la liste 2 sera placée toute entiere dans la liste 1
// liste1 : 1, 20,21,22,23,24, 3,4
// it pointe toujours vers 2
cout<< liste2.empty //true la liste a été vidée 32
Unique : Supprime tous les doublons consécutifs d’une liste : c’est-à-
dire qu’apres avoir éxecuté cette fonction la liste ne contiendra plus
deux éléments l’un à coté de l’autre
- si vous indiquez aucun parametre l’operateur == sera utilisé
Classe deque
• Deque est une classe qui s’utilise de la même
façon que vector
• En plus du push_back et pop_back la classe deque
optimise push_front et pop_front
• Les éléments de vector sont stockés comme pour un
tableau, à des places continues de la mémoire, alors
qu’avec deque , pas nécessairement

34
Il y a trois catégories de conteneurs :
 Séquentiels : l’accès est linéaire, c'est l'ordre qui compte.
 Vector
 Deque
 List
 Associatifs : l’accès par clés.
 Set/multiset
 Map/multimap
 Adaptateurs : l’accès est réglementé.
 pile (stack)
 file (queues)
 files prioritaires (priority queues).
Conteneurs associatifs
•Les éléments sont triés suivant un certain critère.

•Ce critère est une sorte de fonction qui compare


suivant la valeur (le cas de « set/multiset ») ou bien
la clé associée à la valeur (le cas de «
map/multipmap »).

•Par défaut, cette fonction utilise l'opérateur de


comparaison « < », cependant, une autre fonction de
comparaison, se basant sur d'autres critères peut-
être définie pour réaliser cette opération.
Nous avons donc deux catégories de
conteneurs :
 set/multiset : ne contiennent que la valeur, ex:
{jobs, gates, ellison}.
 map/multimap : une paire contenant une clé et
une valeur associée à cette clé, ex:
{(jobs,apple),(gates, microsoft),(ellison,oracle)}
La différence entre « set » et « multiset » est que la valeur peut être
dupliquée.
La différence entre « map » et « multimap » est que la clé peut être
dupliquée.
classe map
Une map Est une simple séquence de paires (clé,
valeur) #include <map>
map <clé, valeur>m;
- clé : c’est la classe qui est utilisé pour accéder aux
éléments. Pour chaque clé correspond une et une seule
valeur associée.
RQ : les clés sont comparable avec l’operateur < sinon
c’est une hash_map
- valeur: c’est la valeur associée. C’est la classe des
éléments contenus dans le tableau
first : les éléments de la colonnes clé
second : les éléments de la colonne valeur
pair <clé_map, type_map> : éléments qui vont etre insère dans
la map 39
Manipulation map

iterator find (clé &) //renvoi un itérateur vers un seul element


pair <iterator, bool> insert (const valeur &)
//renvoi une paire clé, valeur insérer

void erase (iterator)


size_type erase (const clé &)
void clear()
size_type size() //renvoi la taille

size_type max_size() //renvoi la taille max

bool empty()

40
TD : STL Ouvrage Bibliotheque

41
42
Exemple Map : Bibliothéque- Ouvrage

43
Clé , Objet

44
45
46
Classe multimap
Cette classe s’utilise comme la classe map <clé,valeur>
un tableau associatif avec quelques changements :

multiMap<Clé, Valeur> m;

- insert : ne renvoit pas une paire « iterateur-


booleen » puisqu’un élément sera toujours insère ,
cette fonction renverra juste un itérateur vers
l’élèment ajouté

47
- find (cle &) : renvoi un itérateur vers un et un seul des
éléments trouvés à la clé voulue. Pour accéder à toutes les
valeurs associées à un clé :
- La fonction equal_range : renvoie une paire «
itérateur-debut iterateur-fin » pour une clé
- Il suffit de parcourir les éléments depuis l’itérateur de
début renvoyé jusqu’a itérateur de fin
pair<iterateur, iterateur>
multimap ::equal_range(cle &);

- count (cle &) : renvoie le nombre de valeurs


associées à une clé
48
49
Classe set et multiset
• Classe set implémente les ensembles où les
éléments ne peuvent être au plus qu’en un seul
exemplaire
• Set est une map réduite à une seule clé
 Exemple l’ensemble de femme
 Exemple l’ensemble de homme

• Classe multiset implémente les ensembles où


les éléments peuvent être présent en plusieurs
exemplaires

50
Il y a trois catégories de conteneurs :
 Séquentiels : l’accès est linéaire, c'est l'ordre qui compte.
 Vector
 Deque
 List
 Associatifs : l’accès par clés.
 Set/multiset
 Map/multimap
 Adaptateurs : l’accès est réglementé.
 pile (stack)
 file (queues)
 files prioritaires (priority queues).
Adaptateurs : l’accès est réglementé.
Ces classes sont faites pour être utilisées qu’avec
quelques fonctions bien précise.
Celle des piles et des files.

- stack (pile simple)


- queue (file simple)
-priority_queue

52
Classe stack (pile)

Cette classe est utilisé quand un tableau est réduit


à une pile

- push () : ajouter des éléments à son sommet


- top() : acceder à son élément à son sommet
- pop() : supprimer l’élément au sommet, ce qui
permet ensuite d’accéder au élément suivant
- size() retour la taille de la pile
- empty () retour vrai si la pile est vide

53
Classe Queue (file)
Définit des fonction pour manipuler des files
- push() : ajoute un élément en fin de file
- pop() : supprime l’ élément de tête de file
- front() : retour le premier élément de la file ,
c’est celui qui va être traité
- -back() : retour le dernier éléments de la file
- size() retour la taille de la file
- empty () retour vrai si la file est vide

54
Classe priority_queue
Cette classe est un peu plus developpé que « stack
» et « queue », elle permet d’ajouter avec –
- priority_queue::push() l’element ne va pas
toujours se placer au debut comme une pile ou
à la fin comme une file mais à sa place, de telle
sorte que les plus important éléments soit au
debut de la liste.
- ainsi cela permet de toujours traiter en
premier l’element avec la priorité la plus grande

55