POURQUOI HERITER ?

1
Leçon 6 Structures de données dynamiques
IUP 2 Génie Informatique Méthode et Outils pour
la Programmation Françoise Greffier
2
Structures de données dynamiques

• Notion de conteneur
• Généricité
• Implantation dynamique d une pile
• surcharge de l opérateur
• surcharge du constructeur par copie
• Implantation chaînage arrière

3
Des structures de données classiques

• Exemples
• liste, pile, file attente, arbres, graphes ...

Exemples Une liste détudiants, de notes, de
courses
Il existe des algorithmes classiques associées à
ces structures de données parcours, insertion,
suppression ...

• La bibliothèque standard (Standard Template
  Library STL) fournit au programmeur des classes
  prédéfinies qui offrent
• des structures de données classiques
• associées à leurs opérations classiques

4
Conteneur
Un conteneur est une classe très générale
modélisant une collection déléments de
nimporte quel type.

• Il existe deux grandes catégories de conteneurs
  
• les séquences
• les conteneurs associatifs

5
Des composants réutilisables
http//www.sgi.com/tech/stl/
Les opérations de base y sont incluses -
ajouter un élément (insert) - supprimer un
élément (erase) - sélecteur vide? (empty) etc ...
6
Les séquences
On distingue trois séquences vector
(tableau) list (liste) et deque (suite circulaire)
Les classes vector, list et deque se
distinguent par les opérations d accès et par
un compromis entre les coûts des accès,
insertions et suppressions.
7
Les séquences un exemple
Conteneur vector
vectorltintgt v(3) // Declare a vector of 3
elements. v0 7 v1 v0 3 v2
v0 v1 // v0 7, v1 10, v2
17 reverse(v.begin(), v.end()) // v0 17,
v1 10, v2 7
8
Les séquences types abstraits
Les classes (conteneur) - pile stack - file
d attente queue - file d attente prioritaire
priority_queue
9
Les conteneurs associatifs
Contrairement aux séquences, les conteneurs
associatifs peuvent identifier leurs éléments par
la valeur d une clé. Cette clé a parfois pour
valeur une partie de la valeur de l élément. Ces
conteneurs sont particulièrement adaptés dans des
applications où l on doit rechercher des
éléments connaissant leur clé.
10
Les conteneurs associatifs
Ces conteneurs sont  paramétrés  avec le type
de la clé correspondant. .
On doit avoir une relation d ordre total sur les
clés
Opérations sur les clés recherche find
(complexité logarithmique) Comptage selon la clé
count
11
Les conteneurs associatifs

• On trouve quatre conteneurs associatifs
• set clé valeur de l élément
• multiset set avec occurrences multiples
• map élément (clé,v)
• multimap map avec occurrences multiples sur clé

12
Conteneur pile
Un conteneur est un objet contenant d autres
objets

• Nous étudions dans ce chapitre le conteneur
  pile
• Spécification
• Implantation

13
Une pile
A une pile sont associées 4 opérations qui la
caractérisent
Empiler un composant
Consulter(sommet)
Sélecteur vide(état)
Dépiler
Vrai ou faux
Valeur placée au sommet
FINALEMENT Une pile permet de traiterdes
composants dans l ordreinverse de leur
apparition
14
La classe pile
class pile public pile(void) //
constructeur pile(void) // destructeur //
IC non vide X sommet (void) // Sélecteur gt
valeur placée au sommet de IC bool vide(void)
// Sélecteur gt (IC vide?) void empiler(const
X) // x est ajouté au sommet de IC // IC non
vide void depiler(void) // composant placé
au sommet est supprimé private
15
Réutilisabilité
On cherche à écrire des objets réutilisables. On
aimerait concevoir une classe qui modélise une
pile de portée générale une pile nimporte
quels composants.
pileltchargt Pcar pile ltpersonnegt Ppersonne
gt Concevoir une classe générique
16
Facteurs de qualité d un logiciel

• Une classe décrit une famille d objets
• Cohérente
• Lisible
• Extensible
• Réutilisable

Réutilisabilité Possibilité d obtenir toutes
les occurrences d une classe s appliquant à
différents types, en ne décrivant quune seule
fois la classe.
17
template en C
Le mot clé template permet l écriture de
fonctions génériques ou de classes génériques.
template ltclass Xgtclass pile public
pile(void) // constructeur void
empiler(const X) // x est ajouté au sommet de
IC private int taille X t//si
implantation dans un tableau de X //t est un
tableau dynamique
18
Utilisation d une classe générique
void main (void) pile ltchargt Pcar char
ch chnew char20 cout ltlt "\n entrez une
chaîne " cin gtgt chint llength(ch) for (int
i0iltli1) Pcar.empiler(chi)//
cout ltlt "\n Chaîne inversée
" while (!Pcar.vide()) cout ltlt
Pcar.sommet() Pcar.depiler() delete
ch
19
Les paramètres
Le paramètre générique effectif d une classe
peut être un identificateur de type prédéfini ou
un identificateur de classe.
Une classe générique peut avoir plusieurs
paramètres. Syntaxe template ltclass A, class Bgt
20
Les paramètres
Les paramètres peuvent avoir des valeurs par
défaut
template ltclass X, int max100gtclass pile
public ... // IC non vide X sommet (void)
// Sélecteur gt valeur placée au sommet de
IC void empiler(const X) // x est ajouté au
sommet de IC private int taille X Tmax
// si implantation dans un tableau // statique
21
Utilisation d une classe générique
void main (void) pile ltchar,20gt
Pcar //pile de 20 caractères maximum pile
ltpersonnegt PPersonne //pile de 100 personnes
maximum ...
22
Exemple de fonction générique
template ltclass X gt X min (const X A,const X
B) if (AltB) return(A) return (B)
L opérateur lt doit être surchargé dans les
classes qui utiliseront le modèle min
void main (void) int i,j,m cin gtgt i,j int
mmin ltintgt(i,j) ...
23
Implantation de la classe pile

• Implantation dans un tableau statique

private int taille X Tmax // si
implantation dans un tableau // statique
pbs Evaluation de max Limite de la mémoire
statique gt gestion dynamique
24
Implantation de la classe pile

• Implantation dans un tableau dynamique

private int taille X t // si implantation
dans int maximum // un tableau dynamique
Tableau t réservé dans le tas Constructeur avec
un paramètre taille maximum gt bonne
implantation si on peut évaluer la taille
maximum à lutilisation de la pile
25
Utilisation de la pile
void main (void) pile ltchargt
Pcar(25) char ch chnew char(26) cout ltlt "\n
entrez une chaîne " ...
26
Implantation de la pile
include ltiostream.hgt template ltclass Xgt class
pile public pile (int) // constructeur
init taille maxi ... pile (void) //
destructeur private X t // si
implantation dans int indexSommet // un tableau
dynamique int maximum
27
Implantation de la pile

• Constructeur

template ltclass Xgt pileltXgt pile (int max)
t new X max indexSommet -1 maximum
max

• Destructeur

template ltclass Xgt pileltXgt pile (void) if
(t!NULL) delete t
28
Implantation de la pile

• dépiler

template ltclass Xgt void pileltXgt depiler(void)
if (!vide())indexSommet - 1

• Sélecteur vide

template ltclass Xgt bool pileltXgt vide (void)
return (indexSommet -1)
29
Implantation de la pile
template ltclass Xgt void pileltXgt empiler(const
X e) if (indexSommet1 lt maximum) indexSom
met 1 tindexSommet e

• empiler

Remarque on suppose que l opérateurd affectat
ion existe ou est surchargé dans La classe qui
correspond au paramètre X. gt intérêt de la
surcharge des opérateurs
30
Surcharge de lopérateur daffectation
L opérateur d affectation est une méthode
implicite dans toute classe. Par défaut, il
réalise une copie des valeurs qui correspondent
à la section private de la classe.
p1.t
pileltchargt p1 ...
pileltchargt p2 p2p1
Problème Toute modification du tableau des
caractères empilés dans la pile p1 se répercute
dans la pile p2 (et inversement)
p2.t
31
Surcharge de lopérateur daffectation
Pour réaliser une vraie copie de pile par
affectation, il faut surcharger l opérateur
implicite.
pileltchargt p1 ...
pileltchargt p2 p2p1
32
Surcharge de lopérateur daffectation
template ltclass Xgt class pile public pileltXgt
operator (const pileltXgt) // opérateur
d affectation
p1 P2 ltgt p1.operator (p2)
Le comportement habituel de lopérateur
autorise à enchaîner les affectations
p1p2p3 gt la fonction retourne une référence
et l argument est une référence.
33
Implantation
template ltclass Xgt pileltXgt pileltXgt operator
(const pileltXgt p) if (t!NULL) delete t
//on nettoie this tnew X p.maximum maximum
p.maximum for (int i0 iltmaximumi1) tip
.ti indexSommetp.indexSommet return
(this) //retourner une référence sur
l objet courant
34
Surcharge du constructeur par copie
Le constructeur par copie est une méthode
implicite dans toute classe.

• Cette méthode est appelée automatiquement dans
• les opérations suivantes
• Création et initialisation d une nouvelle
  instance
• X I2I1
• X I2(I1)
• passage d un argument par valeur
• retour d une fonction
• return (I)
• // une copie de I est retournée

35
Surcharge du constructeur par copie
Prototype class C public C (const
C) // constructeur par copie ...
Par défaut, cette méthode implicite réalise une
copie des valeurs qui correspondent à la section
private de la classe.
Si l implantation d un objet est dynamique le
constructeur par copie, réalisera par défaut une
copie de pointeur. gt Surcharger cet opérateur
afin quil crée un vrai clône de l instance qui
le déclenche.
36
Implantation
template ltclass Xgt pileltXgt pile (const
pileltXgt p) tnew X p.maximum maximump.ma
ximum for (int i0 iltmaximumi1) tip.ti
indexSommetp.indexSommet
37
Implantation de la classe pile

• Implantation par chaînage de cellules

P.depiler( )
38
Implantation de la classe pile
Les conteneurs doivent-ils stocker nécessairement
des composants ou des pointeurs sur les
composants ?

• Quand le conteneur stocke les composants, et que
  ceux-ci sont homogènes, alors les données peuvent
  être recopiées dans la structure. Cette gestion
  est simplifiée.

Exemple une pile d entiers
39
Implantation de la classe pile
Les conteneurs doivent-ils stocker nécessairement
des composants ou des pointeurs sur les
composants ?

• Quand le conteneur stocke des pointeurs sur les
  composants
• On peut stocker des données non homogènes.
• On évite les copies multiples des données
  (intéressant si la taille du composant est
  importante) .
• La gestion des composants (création, destruction
  est à la charge du programmeur).

Exemple une pile de nombres
Un nombre peut être un entier, un réel, un
complexe, un rationnel.
40
Classe cellule

• include ltiostream.hgt
• template ltclass Xgt
• class cellule
• public
• cellule(X, cellulelt Xgt)//constructeur
• cellule (void) //destructeur
• X composant (void) //sélecteur gt valeur du
  composant

friend class pile ltXgt
private X ptr celluleltXgt ptrprec
41
Classe pile

• template ltclass Xgt
• class pile public
• pile (void) // IC vide est créée
• pile (const pileltXgt) // Constructeur par
  copie
• pile (void) // IC est détruite
• pileltXgt operator(const pileltXgt P) // IC P
• void empiler (const X a) // a est empilé
  dans IC
• //IC non vide
• void depiler (void) // l'élément placé au
  sommet de IC est supprimé
• //IC non vide
• X sommet (void) // sélecteur valeur
  placée au sommet
• bool vide(void) //sélecteur ( IC est
  vide?)

private celluleltXgt ptrSommet //
pointeur sur la cellule sommet
42
Implantation de la classe pile
constructeur
template ltclass Xgt pileltXgt pile(void) if
(ptrSommet ! NULL) detruire( )
template ltclass Xgt pileltXgtpile (void)
ptrSommet NULL
template ltclass Xgt void pileltXgtdetruire (void)
celluleltXgt p while (ptrSommet !
NULL) pptrSommet-gtptrprec delete
(ptrSommet) ptrSommetp
43
Implantation de la classe pile
Pour que l espace occupé par les composants
pointés dans chaque cellule soit libéré lorsque
la fonction détruire est appliquée, il faut que
le destructeur de cellule ait cet effet
Chaque fois que l instruction delete est
appliquée sur un pointeur de cellule, alors le
destructeur de la classe cellule est activé.
Libère l espace occupé par le composant pointé
par ptr