description

1. Programmation Orientée Objets en C++
R. Ben Abbou & A. Zahi
FSTF, Fez, Maroc
LST INFO, FSTF 1

2. Programmation Orientée Objets
Chapitre 6
Les patrons
LST INFO, FSTF 2

3. Plan
 Patrons de fonctions
 Patrons de classes
 Standard Template Library — STL
LST INFO, FSTF 3

4. Patrons de fonctions
 Motivation
 Définition
 Création
 Instanciation
 Paramètres expressions
 Sur définition
 Spécialisation 4

5.  Pour échanger le contenu de deux valeurs numériques, on aura besoin:
 D’une fonction pour les entiers
 D’une fonction pour les réels
Patrons de fonctions —Motivation
void Echange (int& a, int& b) {
int temp;
temp = a;
a = b;
b = temp;
};
void Echange (float& a, float& b) {
float temp;
temp = a;
a = b;
b = temp;
};

6.  En analysant l’exemple précédent, on remarque que c’est le
même code qui traite des types différents (entiers et réels)
 D’où la nécessité de définir une seule fonction pour n’importe
quel type ( paramètres de type)
Patrons de fonctions
 C’est une fonction générique exécutable pour n’importe quel type de
données (int, float, char, int*, char*, float*, classes, etc.)
Patrons de fonctions —Motivation
6

7.  Un patron de fonctions constitue un modèle que le compilateur utilise
pour fabriquer (instancier) des fonctions au besoin
 Exemple
Patrons de fonctions —Définition
void Echange (int& a, int& b) {
int temp;
temp = a;
a = b;
b = temp;
};
void Echange (float& a, float& b) {
float temp;
temp = a;
a = b;
b = temp;
};
Pour traiter les entiers le
compilateur instancie la
fonction
Pour traiter les float le
compilateur instancie la
fonction

8.  Syntaxe
 T: un paramètre de type
Patrons de fonctions —Création
template <class T>
type Fonct(paramètres de type T)
{
code de la fonction
}

9.  Exemple —Echange des valeurs de deux variables
Patrons de fonctions —Création
template <class T>
void Echange (T& a, T& b)
{
T temp;
temp = a;
a = b;
b = temp;
};

10.  Utilisation d’un patron de fonctions — Cas des types simples
 Exemple —Echange des valeurs de deux variables
Patrons de fonctions —Utilisation
void main() {
int n=10, m=20;
float x=12.4,y=20.5;
char c=‘e’, d=‘r’;
Echange(n,m);
Echange(x,y);
Echange(c,d);
}

11.  Cas des types simples
 Exemple —Echange des valeurs de deux variables
Patrons de fonctions —Utilisation
void main() {
int n=10, m=20;
float x=12.4,y=20.5;
char c=‘e’, d=‘r’;
Echange(n,m);
Echange(x,y);
Echange(c,d);
}
void Echange(int& a,int& b)
{
int temp;
temp = a;
a = b;
b = temp;
};
Instanciation

12.  Cas des types simples
 Exemple —Echange des valeurs de deux variables
Patrons de fonctions —Utilisation
void main() {
int n=10, m=20;
float x=12.4,y=20.5;
char c=‘e’, d=‘r’;
Echange(n,m);
Echange(x,y);
Echange(c,d);
}
void Echange(float& a, float& b)
{
float temp;
temp = a;
a = b;
b = temp;
};
Instanciation

13.  Cas des types simples
 Exemple —Echange des valeurs de deux variables
Patrons de fonctions —Utilisation
void main() {
int n=10, m=20;
float x=12.4,y=20.5;
char c=‘e’, d=‘r’;
Echange(n,m);
Echange(x,y);
Echange(c,d);
}
void Echange(char& a,char& b)
{
char temp;
temp = a;
a = b;
b = temp;
};
Instanciation

14.  Cas des pointeurs
 Exemple —Echange des valeurs de deux variables
 La fonction permute les adresses et non le contenu
Patrons de fonctions —Utilisation
void main()
{
char *s = ’’avant’’;
char *r = ’’après’’;
Echange(s,r);
}
void Echange (char*& a, char*& b)
{
char *temp;
temp = a;
a = b;
b = temp;
};
Instanciation

15.  Cas du type classe
 Exemple —Echange des valeurs de deux variables
 les opérateurs utilisés dans le patron doivent être applicables aux
objets de la classe
Patrons de fonctions —Utilisation
class Complexe {
float im, re;
public:
Complexe() {} // OBLIGATOIRE
Complexe(float x, float y){
im=x;re=y;
}
void afficher() {
cout << re << ’’ ** ’’ << im;
}
};
void main(){
Complexe z1(0,0);
Complexe z2(1,1);
Echange(z1,z2);
}
void Echange(Complexe& a, Complexe& b)
{
Complexe temp;
temp = a;
a = b;
b = temp;
};

16.  Dans un patron on peut imposer à un ou plusieurs paramètres un type
donné
 Syntaxe
Patrons de fonctions —Paramètres fixes
template <class T>
type fonct(params de type T, param muets) {
code
}

17.  Exemple — affichage d’un tableau d’éléments de type quelconque
 Dans le cas d’un paramètre de type classe l’opérateur << doit être
surchargé .
Patrons de fonctions —Paramètres fixes
template <class T>
void afficher(T *tab,int n)
{
for (int i=0; i<n; i++)
cout << tab[i] << ’’t’’;
}
void main() {
int ta[10] ={1,2,7,5,8}.
int n=5;
afficher(ta,n);
}

18.  Possibilité de surdéfinir les patrons de fonctions
 Mêmes règles que pour les fonctions ordinaires
(même nom , arguments différents )
 Peuvent être surdéfini
 Les patrons ne comportant que des paramètres de type
 Les patrons comportant les paramètres expressions
Patron de fonctions —Surdéfinition
18

19.  Exemple — l’échange du contenu de deux variables peut être
surdéfinie pour trois variables
Patrons de fonctions —Surdéfinition
template <class T>
void Echange (T& a, T& b){
T temp;
temp = a;
a = b;
b = temp;
}
template <class T>
void Echange(T& a, T& b, T& c){
T temp;
temp = a;
a = b;
b = c;
c = temp;
}
Surdéfinition

20.  Un patron défini une famille de fonctions qui réalisent
le même algorithme
 Existence de cas particuliers
 Possibilité de traiter ces cas par une fonction portant le
même nom
Spécialisation du patron pour chaque cas
Patron de fonctions —Spécialisation

21.  Exemple — L’ échange de valeurs dans le cas des pointeurs conduit à la
permutation des adresses pas convenable
Patrons de fonctions —Spécialisation
template <class T>
void Echange (T& a, T& b){
T temp;
temp = a;
a = b;
b = temp;
}
void Echange (char* a, char* b){
char temp[40];
strcpy(temp,a);
strcpy(a,b);
strcpy(b,temp);
}
Spécialisation au
cas des pointeurs

22.  Un paramètre de type ne peut correspondre à un pointeur
 Cas d’un patron possédant des objets locales
 T x — ne peut être appliqué qu’aux classes ayant un
constructeur par défaut ou sans paramètres
 T x(p1,p2,...) — ne peut être appliqué qu’aux classes
ayant un constructeur avec le même nombre de paramètres
Patron de fonctions —Remarques
template<class T>
void fct (T* )

23. Patrons de classes
 Définition
 Création
 Utilisation
 Paramètres
 Amitié
 Héritage
23

24.  Classes paramétrées par des types et éventuellement des
expressions
 Modèles utilisés par le compilateur pour créer des classes au
besoin (adaptées aux types traités )
 Utiles pour les conteneurs d’objets —Tableau, Pile, File, etc.
Patrons de classes —Définition
24

25.  Syntaxe de définition d’une classe patron
Patrons de classes —Création
template <class T,class R, class U, …>
class class_name
{
//attributs de type T
//attributs de type R
//autres attributs
…
//fonctions ayant des paramètres de type T
type fct(parametres de type T);
}
template <class T>
type class_name <T,…>::fct(parametres){
code
}

26.  Exemple —Patron de classes pour les tableaux de 10 objets
Patrons de classes —Création
template <class T>
class Tableau {
T t[10];
int n;
public:
Tableau (int m=0){n=m;}
void afficher();
void ajouter(T&);
};
// définition de la fonction qui
affiche les éléments du tableau
template <class T>
void Tableau <T>::afficher(){
for(int i=0; i<n; i++)
cout << t[i] <<’’t’’;
}
// définition de la fonction qui ajoute
un élément au tableau
template <class T>
void Tableau <T>::ajouter(T& a){
t[n++]=a;
}

27.  Se traduit par une déclaration du genre:
 val_type est l’un des types : int, float, char, classes, etc.
 Conduit à une instanciation d’une classe dans laquelle le
paramètre T prend la valeur val_type
Patrons de classes —Utilisation
class_name <val_type> identif;

28.  Exemple — tableau de 10 éléments
Patrons de classes —Utilisation
void main()
{
//tableau d’entiers
Tableau <int> ti;
//tableau de réels
Tableau <float> tf;
//tableau de complexe
Tableau <complexe> pt;
}
template <class T>
class Tableau {
T t[10];
int n;
public:
Tableau(){n=0;}
void afficher();
void ajouter(T&);
};
class Tab_1 {
int t[10]; int n;
public:
Tableau(){n=0;}
void afficher();
void ajouter(int &);

29.  Exemple — tableau de 10 éléments
Patrons de classes —Utilisation
void main()
{
//tableau d’entiers
Tableau <int> ti;
//tableau de réels
Tableau <float> tf;
//tableau de complexe
Tableau <complexe> pt;
}
template <class T>
class Tableau {
T t[10];
int n;
public:
Tableau(){n=0;}
void afficher();
void ajouter(T&);
};
class Tab_1 {
float t[10]; int n;
public:
Tableau(){n=0;}
void afficher();
void ajouter(float &);

30.  Exemple — tableau de 10 éléments
Patrons de classes —Utilisation
void main()
{
//tableau d’entiers
Tableau <int> ti;
//tableau de réels
Tableau <float> tf;
//tableau de complexe
Tableau <complexe> pt;
}
template <class T>
class Tableau {
T t[10];
int n;
public:
Tableau(){n=0;}
void afficher();
void ajouter(T&);
};
class Tab_ 3 {
complexe t[10]; int n;
public:
Tableau(){n=0;}
void afficher();
void ajouter(complexe &);

31.  Peuvent être en nombre quelconque
Patrons de classes —paramètres de type
void main()
{
test <int, float, char> t1;
test <int*, float, char> t2;
}
template < calss T, class R, class S>
class test {
T x;
R y[5];
S *z;
…
};
class test {
int x;
float y[5];
char *z;
…
};
Définition
Instanciation
class test {
int* x;
float y[5];
char *z;
…
};

32.  On impose à des paramètres de prendre des types fixes
Patrons de classes —paramètres expressions
void main()
{
test<int,V1,V2>
//V1 valeur de type type1
//V2 valeur de type type2
}
template < calss T, type1 P1, type2 P2>
class test {
T x;
T y[P1];
.
.
.
};
Définition
Instanciation

33.  Exemple
Patrons de classes —paramètres expressions
void main()
{
Tableau<int, 4> ti;
for (int i=0; i<4; i++) ti[i]=i;
ti.afficher();
}
template <class T, int taille>
class Tableau {
T t[taille];
public:
Tableau():{}
void afficher();
};
template <class T>
void Tableau <T>::afficher(){
for(int i=0; i<taille; i++)
cout << t[i] <<’’t’’;
}
Définition
Instanciation

34. Patrons de classes —Remarques
 Possibilité pour un patron de classes de comporter des
membres données statique
 Possibilité d’avoir un argument formel pour une fonction
patron de type patron de classes
template <class T> class A { … }
template <class T> void MaFonction(A<T>){
.
.
.
}

35.  Possibilité de traiter des cas particuliers —Par la
redéfinition d’une fonction
 Exemple
Patrons de classes —Spécialisation des patrons
template <class T,class U>
class A {
T x;
U y;
public:
void afficher();
};
// définition de la fonction membre du patron
template <class T,class U>
void A<T,U>::afficher(){
cout << x << y;
}
template <class U>
void A<char, U>::afficher(){
cout << ‘affichage des caractères’ << x;
}
Spécialisation au
caractères

36.  Possibilité de traiter des cas particuliers —Par la
définition d’une nouvelle classe
 Exemple
Patrons de classes —Spécialisation des patrons
template <class T>
class A {
T x;
public:
void afficher();
};
// définition de la fonction membre du patron
template <class T>
void A<T>::afficher(){
cout << x;
}
class A<int*>::afficher(){ {
cout << *x; // nouvelle définition ;
}
Spécialisation de la classe
au pointeurs d’entiers

37.  On peut transmettre des arguments par défaut à un
patron de classes
 Exemple
Patrons de classes —Paramètres par défaut
template <int taille=4, class T=complexe>
class Tab {
T t[taille];
public:
T():{}
void afficher();
};
main() {
Tab <int> t1;// un tableau de 4 entiers
Tab <10,int> t2;// un tableau de 10 entiers
Tab <2> t3;// un tableau de 2 complexes
Tab <> t4;// un tableau de 4 complexes
}

38.  On peut déclarer un patron de fonctions comme une
fonction membre d’une classe ordinaire
 Exemple
Patrons de classes —Patrons de fonctions membres
class A {
int x;
public:
template <class T> void fct( T a)
{ … };
};

39.  On peut déclarer un patron de fonctions comme une fonction
membre d’une classe patron
 Exemple
Patrons de classes —Patrons de fonctions membres
template <class T>
class A {
T x;
public:
template <class U> void fct( U a)
{ … };
};

40.  Nouvelles possibilités de déclaration d’amitié —trois possibilités
 Fonctions ordinaires
 Instances particulières de classes patrons ou de fonctions patrons
 Un autre patron de fonctions ou de classes
Patrons de classes —Amitié

41.  Fonctions ordinaires
template <class T>
class A {
T x;
public:
//B est amie de toute instance de la classe A
friend class B;
//fct est amie de toute instance de la classe A
friend void fct(…);
};
Patrons de classes —Amitié
2011-
2012
LST INFO,
FSTF
41

42.  Instances particulières de classes patrons ou de fonctions patrons :
 1er cas : amitié sur des paramètres effectifs
template <class U> class B {…}
template <class T> void fct(T x) {…}
template <class T>
class A {
T x;
public:
//B<int> est amie de toute instance de la classe A
friend class B<int>;
//fct(float) est amie de toute instance de la classe A
friend void fct(float);
};
Patrons de classes —Amitié
2011-
2012
LST INFO,
FSTF
42

43.  Instances particulières de classes patrons ou de fonctions patrons :
 2ème cas : amitié sur des paramètres muets
template <class U> class B {…}
template <class T> void fct(T x) {…}
template <class T>
class A {
T x;
public:
//B<T> est amie de toute instance de la classe A
friend class B<T>;
//fct(T) est amie de toute instance de la classe A
friend void fct(T);
};
Patrons de classes —Amitié
2011-
2012
LST INFO,
FSTF
43

44.  Un autre patron de fonctions ou de classes
 2ème cas : amitié sur des paramètres muets
Template <class T>
class A {
T x;
public:
//toute instance de B est amie de toute instance de A
template <class X> friend class B<X>;
//toute instance de fct est amie de toute instance de A
template <class Y> friend void fct(Y);
};
Patrons de classes —Amitié
2011-
2012
LST INFO,
FSTF
44

45.  Trois possibilités
 Classe ordinaire dérivée d’une classe patron
 Patron de classes dérivée d’une classe ordinaire
 Patron de classes dérivée d’un patron de classes
Patrons de classes —Héritage

46.  Classe ordinaire dérivée d’une classe patron
Patrons de classes —Héritage
template <class T>
class A {
T x;
public:
}
// B dérive de la classe patron A<int>
class B : public A<int> {
…
}

47.  Patron de classes dérivée d’une classe ordinaire
Patrons de classes —Héritage
class A {
int x;
public:
}
// B dérive de la classe patron A<T>
template <class T>
class B : public A {
…
}

48.  Patron de classes dérivé avec l’introduction de nouveaux
paramètres
Patrons de classes —Héritage
template <class T>
class A {
T x;
public:
}
// B dérive de la classe patron A<T>
// B dérive de la classe patron A<T>
template <class T,class U>
class B : public A<T> {
…
}

49. Standard Template Library —STL
 Vue générale
 Modèle de base
 Conteneurs
49

50.  La bibliothèque standard du C++
 Formée de trois grandes composantes:
 STL — Standard Template Library
 Classes usuelles — String, flux d’entrée/sortie (cin, cout, cerr, etc.)
 Bibliothèque du language C.
 Il ne faut confonde Bibliothèque standard du C++ et STL
Standard Template Library —Vue générale
50

51.  Qu’est ce que STL?
 Une bibliothèque de classes et d’algorithmes contenant:
 des patrons de classes qui implémentent les structures de données usuelles,
 des patrons d’algorithmes qui implémentent les algorithmes classiques optimisées
 Conçue par Stepanov et Lee
 Repose sur la généricité — les classes et les algorithmes fonctionnent avec n’importe quel
type prédéfini dans le langage ou défini par l’utilisateur
 Séparation des algorithmes et des structures des données.
 Développée par Heweet Packard et Scilicon graphics
 Intégrée au langage C++
Standard Template Library —Vue générale
51

52.  Avantages de STL
 Permet au programmeur de se focaliser sur les fonctionnalités de
son application — «le programmeur n’a pas à réinventer la roue »
 Fournit une meilleure efficacité — les structures de données et les
algorithmes usuelles sont optimisés et validés.
 Favorise la réutilisabilité du code.
Standard Template Library —Vue générale
52

53.  Comporte les éléments suivants :
 Conteneurs (container) — Implémentation des structures de données les
plus courantes avec leur allocation/désallocation mémoire automatique
 Itérateurs (iterator) — Permettent l'accès, le parcours et la manipulation
des éléments des conteneurs
 Algorithmes (algorithm) — Implémentation d'algorithmes usuels tels que
la recherche, le tri, etc.
Standard Template Library —Modèle de base

54.  Séparation entre les élements :
 Les conteneurs stockent les données sans savoir les algorithmes qui les manipulent
 Les algorithmes manipulent les données sans savoir le conteneur qui le contient.
 Les itérateurs assurent l’interaction entre les conteneurs et les algorithmes
Standard Template Library —Modèle de base
Algorithmes Containers
Itérateurs

55.  Hiérarchie
Standard Template Library —Conteneurs
Conteneurs
Séquences
élémentaires
Adaptateurs
de séquence
list
vector deque
stack queue priority_queue
map
multimap
set
multiset
Conteneurs
de séquence
Conteneurs
associatifs

56.  Séquences élémentaires
Standard Template Library —Conteneurs
 Accès direct
 Insertion optimisé en fin
vector
 Accès direct
 Insertion optimisé en début ou en fin
dque—double end queue
 Accès séquentiel
 Insertion optimisée en tout point
list