Vous êtes sur la page 1sur 120

Programmation Orientée Objet

en C++
Chapitre 1 : Notions de base
Auteur : A. MOHAMMEDI
Les classes en C++

 Le mécanisme de classes du langage C++


permet à l'utilisateur d'introduire des nouveaux
types de données.
 Les données membres de la classe, qui
définissent sa représentation interne.
 Les fonctions membres de la classe qui
définissent l'ensemble des opérations pouvant
être appliquées aux objets de ce type classe.

08/12/2019 INSIM TO 2
Les classes
 L'en-tête : mot clé class suivi du nom de la classe.
 Le corps : mis entre accolade, il est constitué des différentes
données et méthodes membres de la classe.
 Une définition de classe est terminée par un point-virgule ou
par une liste de déclaration.
 Exemple :
l'en-tête de la classe
class personne
{
string nom; corps de la classe

string prenom;
...}
;
08/12/2019 INSIM TO 3
Les données membres d'une classe
 Les données membres d'une classe sont
déclarées de la même façon que les variables.
 Elles sont incluses dans le corps de la classe.
 Elles sont aussi dites : attributs de la classe.
 Exemple :
#include <string>
class personne {
string nom; nom, prenom, age sont les
string prenom; données membres de la
classe personne
short int age;
};
08/12/2019 INSIM TO 4
Les données membres d'une classe

 Une donnée membre de classe peut-être d'un


type quelconque.
 Une donnée membre ne peut être initialisée
explicitement dans le corps de la classe, sauf
pour une exception mineure concernant les
données membres statiques.

08/12/2019 INSIM TO 5
Les fonctions membres d'une classe

 Les fonctions membres, appelées aussi méthodes de


la classe, déterminent tous les services et les
comportements possibles d'un objet.
 Exemple :
#include <string> Les fonctions
class personne { membres de la
...//les données membres de la classe classe

string getNom();
string getPrenom();
string getAge() {return age;}
};

08/12/2019 INSIM TO 6
Les fonctions membres d'une classe

 La définition d'une fonction membre peut être


placée soit dans le corps de la classe (exemple
de la fonction getAge()), soit à l'extérieur de la
classe.
 Une fonction membre doit d'abord être
déclarée à l'intérieur du corps de sa classe
avant sa définition hors du corps de sa classe.

08/12/2019 INSIM TO 7
Les fonctions membres d'une classe

 Exemple :
Implémentation des fonctions getNom() et
getPrenom() à l'extérieur de la classe se fait
comme suit :
//utilisation de l'opérateur :: pour accéder au nom de la
fonction
string personne::getNom(){ return nom;}
string personne::getPrenom()
{return Prenom;}

08/12/2019 INSIM TO 8
Objets de classe (instanciation simple)

 On peut définir des objets d'une classe de


deux façons :
1. En spécifiant le mot-clé class suivi du nom de la
classe;
2. En spécifiant uniquement le nom de la classe.
 Exemple : les objets de type personne
peuvent être définis comme suit :
class personne p1; //ou bien
personne p2;

08/12/2019 INSIM TO 9
Objets de classe (instanciation simple)

 La définition d'une classe n'alloue aucune mémoire.


 La mémoire est uniquement réservée quand un objet
de type classe est instancié.
 Chaque objet de classe possède sa propre copie des
données membres de la classe.
 Les objets d'un type classe se comportent comme les
autres objets en termes de portée et du durée de vie.
 Des pointeurs et des références vers des objets de
classe peuvent également être déclarés.

08/12/2019 INSIM TO 10
Accès à un membre de classe

 L'accès aux données et fonctions d'un objet


s'effectue en utilisant les opérateurs d'accès
point ou flèche :
nom_objet.nom_membre //ou bien
nom_ptr_objet->nom_membre

08/12/2019 INSIM TO 11
Masquage d'information

 Les restrictions d'accès aux membres de classe sont :


– public : accès illimité depuis n'importe quel endroit du
programme
– private : un membre privé est accessible uniquement aux
fonctions membres et "amies" de la classe
– protected : un membre protégé se comporte comme un
membre public pour une classe dérivée et comme un
membre privé pour le reste du programme
 public, private, protected : sont dits spécificateurs
d'accès

08/12/2019 INSIM TO 12
Les classes et fonctions amies

 But : autoriser des fonctions à accéder à des membres


non publics.
 Une déclaration de classe amie commence par le mot-
clé friend.
 Il ne peut apparaître que dans une définition de
classe.
 Les champs amis ne sont pas membres de la classe
donnant son amitié
 il ne sont pas affectés par les sections public, private, et
protected dans lesquelles ils sont déclarés à l'intérieur du
corps de la classe.
08/12/2019 INSIM TO 13
Les classes et fonctions amies
 Un membre ami peut-être une fonction
d'espace de noms, une fonction membres d'une
autre classe, ou une classe complète.
 Toutes les fonctions membres de la classe
amie peuvent accéder aux membres non
publics de la classe donnant son amitié.
Classe B Possibilité
Classe A Relation d’amitié d’accès
friend class A;
Membres de la
classe A Membres privés
et protégés de
la classe B

08/12/2019 INSIM TO 14
Les classes et fonctions amies
 Exemple :
La fonction non membre affiche() qui permet d'afficher les informations
relatives à un objet de la classe personne :
void affiche (const personne & p)
{

!
cout << "Le nom : \t" << p.nom << endl;
cout << "Age :\t" << p.age << endl;
}
 Solution :
– Définir la fonction affiche() comme amie de la classe personne,
comme suit :
class personne {
friend void affiche (const personne &);
...//suite du corps de la classe
};

08/12/2019 INSIM TO 15
Déclaration versus définition de classe
 Déclaration : introduit le nom de la classe dans
le programme et indique que ce nom se réfère
à un type classe :
class nom_classe;

 Définition : Une classe est considérée comme


définie dès que son corps de classe est
rencontré. Une fois la classe définie, tous les
membres de la classe sont connus. La taille de
la classe est également connue.
08/12/2019 INSIM TO 16
Déclaration versus définition de classe

 On ne peut définir d'objets d'un type classe si


la classe n'est pas définie préalablement.
 Un pointeur ou une référence vers ce type
classe peut-être déclarée.
 Une donnée membre peut-être déclarée comme
étant de type classe, à condition que la
définition de la classe correspondante a déjà
été rencontrée.

08/12/2019 INSIM TO 17
Déclaration versus définition de classe

 Une classe n'étant pas considérée comme définie tant


que son corps n'est pas complet
 Une classe ne peut avoir de données membres de son
propre type.
 Une classe peut avoir des données membres qui sont
des pointeurs ou des références vers son propre type.
 C'est ce qui permet la définition des classes récursives
et/ou de classes mutuellement récursives.

08/12/2019 INSIM TO 18
Fonctions membres en ligne (inline)

 Les définitions de fonctions fournies dans le corps de


la classe sont dites définies en ligne.
 Ces fonctions sont automatiquement gérées comme
des fonctions avec l'attribut inline.
 Exemple :
class personne {
public : //attributs nom, prenom, age
string getNom () {return nom;}
inline string getPrenom() {return prenom;}
inline int getAge() {return age;}
};
08/12/2019 INSIM TO 19
Fonctions membres en ligne (inline)

 Il vaut mieux définir les fonctions membres


comportant plus d'une ligne à l'extérieur du
corps de la classe.
 Les fonctions en ligne doivent être définies
dans tout fichier texte où elles sont appelées.
 La fonction membre en ligne non définie dans
le corps de la classe sera placée dans le fichier
d'en-tête dans lequel apparaît la définition de la
classe.

08/12/2019 INSIM TO 20
Les fonctions membres const

 On peut aussi définir des objets de classe constants.


 Les fonctions membres const sont des fonctions qui
ne modifient pas l'état d'un objet de la classe.
 Le mot-clé const est placé entre la liste de paramètres
et le corps de la fonction membre.
 Une fonction membre constante définie en dehors du
corps de la classe spécifiera le mot-clé const, tant
dans sa déclaration que dans sa définition.

08/12/2019 INSIM TO 21
Les fonctions membres const

 Seules les fonctions membres const peuvent être


invoquées pour un objet constant de classe.
 Une fonction membre const peut être appelée pour un
objet non constant
 Une fonction membre const peut surcharger une
fonction non const dans la classe
 Priorité de la fonction non const sur la surcharge
const lorsqu’on invoque une fonction sur un objet non
const

08/12/2019 INSIM TO 22
Les fonctions membres const

 Exemple :
class personne {
public :
string getNom () const;
int getAge() const {return age;}
...};
//définition de la fonction const getNom() à
l'extérieur de la classe
String personne::getNom()const
{return nom;}
08/12/2019 INSIM TO 23
Le pointeur implicite this

 Le pointeur this : est un pointeur implicite


ajouté automatiquement par le compilateur.
 Il sauvegarde l’adresse de l’objet qui le
contient. Objet A
this = @

 Chaque fonction membre d'une classe contient


le pointeur this qui adresse l'objet pour lequel
elle est appelée.
08/12/2019 INSIM TO 24
Le pointeur implicite this

 Le programmeur peut aussi se référer au pointeur this


de façon explicite.
 Exemple :
– On ajouter à la classe personne une fonction membre qui
teste l'égalité entre l'objet appelant la fonction et l'objet
passé en argument :
class personne {
public : ...
bool isEqual (const personne &rhs) const {
if (&rhs == this)
return true;
else //faire la comparaison
}
};
08/12/2019 INSIM TO 25
Initialisation d'objets de classe
 L'initialisation des objets d'une classe est effectuée
par le constructeur de la classe.
 Un constructeur est une fonction membre spéciale qui
porte le même nom que la classe dans laquelle il est
défini.
 Une classe peut définir plusieurs constructeurs
 Un constructeur ne doit pas spécifier de type retour,
même pas void.
 Le langage C++ impose l'application d'un
constructeur à un objet de classe avant sa première
utilisation.
08/12/2019 INSIM TO 26
Le(s) constructeur(s) de classe

 Le constructeur par défaut


 Le constructeur avec arguments
 Utilisation des listes d’initialisation
 Le constructeur de copie

08/12/2019 INSIM TO 27
Le constructeur par défaut
 Il peut ne pas être défini explicitement à condition
qu’aucun autre constructeur ne soit défini dans la
classe
 Le constructeur par défaut d'une classe porte le même
nom que sa classe, et ne spécifie aucun argument
– Syntaxe :
nom_classe();

 Possibilité d’utilisation d’une liste d’initialisation


– Syntaxe :
nom_classe () :
attribut1 (val1), attribut2 (val2), …, attributN (valN)
{ }

08/12/2019 INSIM TO 28
Le constructeur avec arguments

 Permet de spécifier des arguments d’initialisation des


objets
– Syntaxe :
nom_classe (type_arg1 arg1, type_arg2 arg2, …, type_argN
argN);

 Les arguments sont utilisés dans des listes


d’initialisation
– Syntaxe :
nom_classe (type_arg1 arg1, type_arg2 arg2, …, type_argN
argN) :
attribut1 (arg1), attribut2 (arg2), …, attributN (argN)
{ }

08/12/2019 INSIM TO 29
Le constructeur de copie
 L'initialisation d'un objet de classe avec un autre objet
de sa classe s'appelle initialisation membre à membre
par défaut.
 Le concepteur de la classe peut fournir un
constructeur de copie de classe explicite.
– Syntaxe :
nom_classe(const nom_classe & rhs);
 Il est invoqué chaque fois qu'un objet de classe est
initialisé avec un autre objet de sa classe.
 Il est nécessaire de le définir lorsque qu'on a dans la
classe des données membres de type pointeur.

08/12/2019 INSIM TO 30
Exemples de constructeurs
 Exemple : Soit la classe personne suivante :
class personne {
public :
string nom;
string prenom;
int age; Le constructeur par défaut
personne () { }
personne (string str_n, string str_p, int i)
{
nom = str_n;
prenom = str_p; Le constructeur avec
age = i; arguments
}
};

08/12/2019 INSIM TO 31
Exemples de constructeurs
 Exemple : On peut redéfinir le constructeur par défaut et le
constructeur avec arguments à l'aide de listes d'initialisation
comme suit :
class personne { Le constructeur par
public : défaut avec des valeurs
string nom; initiales pour chaque
Le constructeur avec
string prenom; donnée membre
arguments plus
int age; efficace
personne (): nom ("x"), prenom ("y"), age (18)
{}
personne (string str_n, string str_p, int i) :
nom (str_n), prenom (str_p), age (i) {}
};

08/12/2019 INSIM TO 32
Exemples de constructeurs
 Exemple :constructeur de copie
class personne {
public :

personne (const personne &rhs)
{ if (&rhs != this)
{
nom = rhs.nom;
prenom = rhs.prenom
age = rhs.age;
}
}
};

08/12/2019 INSIM TO 33
Exemples de construction

 Toutes ces définitions de objets personne sont


possibles :
personne p1;
personne p2 ("omar", "ali", 25);
personne p3 = personne ("Hugo","Victor",
50);
personne *ptr, *ptr2;
ptr = new personne;
ptr2 = new personne ("Omar", "Ali", 25);
personne p4 (p2);

08/12/2019 INSIM TO 34
Affectation d'objets de classe
 L'affectation d'un objet de classe par un autre objet de sa classe
est gérée par l'affectation membre à membre par défaut.
 Création implicite pour chaque classe de l'opérateur
d'affectation de copie.
 Pour la classe personne précédente, l'opérateur ressemble à ce
qui suit :
inline personne& operator= (const personne &rhs)
{
nom = rhs.nom;
age = rhs.age;
return *this;
}

08/12/2019 INSIM TO 35
Affectation d'objets de classe

 Si l'initialisation membre à membre par défaut


n'est pas appropriée pour une classe, alors
l'affectation membre à membre ne l'est pas non
plus.
 On doit alors fournir une opération
d'affectation explicite : c'est la surcharge de
l'opérateur "=" .
 Ce processus est identique à l'initialisation
membre à membre par défaut.

08/12/2019 INSIM TO 36
Destruction d'objets de classe
 Le destructeur des objets est la fonction inverse du
constructeur
– Le constructeur permet l'acquisition automatique de
ressources
 allocation de la mémoire,
 acquisition d'une ressource UC,
 d’un fichier, etc.
– Le destructeur permet la désallocation automatique ou la
libération d'une ressource associée à un objet de classe sur
le point de terminer sa durée de vie
 Le destructeur spécifie le comportement d’un objet en
fin de vie

08/12/2019 INSIM TO 37
Destruction d'objets de classe

 La syntaxe est comme suit :


~nom_classe();
 On ne doit spécifier dans le destructeur ni une valeur
retour ni de paramètres.
 Chaque classe a un destructeur unique.
 Le destructeur n'est pas nécessaire pour toutes les
classes.
 En général, le destructeur est invoqué
automatiquement par le compilateur lorsqu'un objet
termine sa durée de vie.

08/12/2019 INSIM TO 38
Programmation orientée objet
en C++
Chapitre 2 : Héritage & polymorphisme
Auteur : N. TAMANI
L’héritage entre classes

 L’héritage est l’un des mécanismes sur


lesquels se base la programmation orientée
objet
 Il permet la réutilisation des classes déjà
définies
 L’héritage permet à une classe d'être définie en
récupérant les données membres et le
comportement d'une ou de plusieurs classes
existantes.

08/12/2019 INSIM TO 40
Différents types d'héritage
 L'héritage de module : c'est une simple réutilisation
de code par copie des informations de la classe
parente vers la classe dérivée.
– Exemple : construire une classe file (fifo) à l'aide d'une
classe vecteur. L'héritage des informations du vecteur dans
la file, mais non pas le comportement, car ce dernier n'est
pas opportun pour la file.
 La composition : une forme d'héritage de module
(implémentation de la relation d’agrégation entre
classes)

08/12/2019 INSIM TO 41
Différents types d'héritage

 L'héritage de sous-type : c’est l’implémentation de la


relation "est un" ("est sorte de") entre classe.
– C'est une généralisation/spécialisation des classes à travers
un mécanisme de dérivation de classes.
– Exemple : un étudiant est une personne;
 Une classe dérivée hérite des données et fonctions
membres de sa classe de base et peut les utiliser
comme si elles étaient membres de la classe dérivée
 Si les classes de bases et dérivées partagent la même
interface publique, la classe dérivée et dite sous-type
de la classe de base.
08/12/2019 INSIM TO 42
L’héritage en C++

 L’héritage simple
 L’héritage multiple
 L’héritage virtuel
 L’héritage abstrait
 Le polymorphisme : corollaire à l’héritage
 La composition

08/12/2019 INSIM TO 43
Implémentation de l'héritage en C++
 La syntaxe générale pour spécifier l’héritage entre classes est :
class derived : liste_de_dérivation
{
//... définition de la classe dérivée
};
 derived : c'est le nom de la classe dérivée;
 liste_de_dérivation : c'est une liste formée de
access_specificator base_class séparés par des virgules;
 base_class : est le nom de la classe de base;
 Les classes spécifiées dans la liste de dérivation doivent être définies
avant d'être utilisées comme des classes de base;

08/12/2019 INSIM TO 44
Implémentation de l'héritage en C++
 access_specificator : un modificateur qui peut
être :
– public : d'où l'héritage public (héritage de sous-
type);
– protected : d'où l'héritage protégé;
– private : d'où l'héritage privé.
 Le spécificateur indique la propagation de
l’héritage en termes de droits d'accès aux
données et fonctions membres de la classe de
base dans la classe dérivée :
08/12/2019 INSIM TO 45
Implémentation de l'héritage en C++

 public : c'est le spécificateur le plus utilisé; la


protection des membres de la classe de base reste
inchangée au niveau de la classe dérivée
 protected : les membres publics de la classe de base
deviennent protected dans la classe dérivée
 private : les membres public et protected de la classe
de base deviennent private dans la classe dérivée
 Redéfinition de l’interface d’accès vers les membres de la
classe de base dans la classe dérivée

08/12/2019 INSIM TO 46
L’héritage simple (unique)
 Un héritage simple est une dérivation de classe
dans laquelle chaque classe dérive (sous
classe) d'une seule et unique classe de base
(super classe).
Personne
Les membres communs Membres de la
aux classes étudiant et classe personne
enseignant sont mis dans
la classe personne

Étudiant Enseignant
Membres de la Membres de la
classe étudiant classe enseignant

08/12/2019 INSIM TO 47
L’héritage simple (unique)

 La syntaxe : La traduction du schéma


précédent en code C++ est comme suit :
class personne
{ ... };
class etudiant : public personne
{ … };
class enseignant : public personne
{ … };

08/12/2019 INSIM TO 48
Construction des objets dans l'héritage simple

 La règle générale :
– Instancier un objet de la classe dérivée déclenche
un processus d'appel au constructeur de la classe
de base, puis enfin le constructeur de la classe
dérivée concernée.
 Chaque objet de la classe dérivée possède un
sous objet de sa classe de base.

08/12/2019 INSIM TO 49
Construction des objets dans l'héritage simple

 Exemple : création d’un objet étudiant

1.Création du sous
objet personne

Personne

Étudiant

2. Création de l’objet
étudiant

08/12/2019 INSIM TO 50
Instanciation par défaut

 La construction par défaut d'un objet de la


classe dérivée se fait en deux étapes :
1. L'appel au constructeur par défaut de la classe de
base en premier, pour construire le sous objet de
la classe de base;
2. L'appel au constructeur par défaut de la classe
dérivée, en seconde étape.
 L’invocation des constructeurs de base de fait
automatiquement par le compilateur.
08/12/2019 INSIM TO 51
Instanciation avec arguments

 Les instanciations nécessitant un appel à un


constructeur avec arguments de la classe de
base.
 Dans la classe dérivée, un constructeur avec
arguments passe des paramètres à un
constructeur de la classe de base en l'invoquant
de façon explicite dans la liste d'initialisation.

08/12/2019 INSIM TO 52
Instanciation avec arguments
 Exemple :
class personne {
public :
//...
personne (string n, string p, int a) :
nom (n), prenom (p), age (a) {}
//...}; Appel explicite du
class etudiant : public personne { constructeur avec
public : arguments de la classe
personne
int anne_etud;
etudiant (string ne, string pe, int ae, int
anne) :
personne (ne, pe, ae),
anne_etud (an) { }
//...};

08/12/2019 INSIM TO 53
Accès aux membres de la classe de base
 Les membres publics et protégés hérités de la classe de base
peuvent être accédés directement comme s'ils étaient membres
de la classe dérivée.
 Une exception : Quand la désignation du membre de la classe
de base est réutilisé dans la classe dérivée.
– Exemple :  Priorité, lors des
Réutilisation invocations
de la même
class personne { non qualifiées,
désignation dans laà la fonction
classe dérivée
public : redéfinie dans la classe dérivée
void se_deplacer () {//à pied}
//...};
class etudiant : public personne {
public :
void se_deplacer () {//par bus}
//...};

08/12/2019 INSIM TO 54
Accès aux membres de la classe de base

 La classe dérivée n'a d'accès direct aux


membres protégés que pour son propre sous
objet de la classe de base.
 Elle n'a pas accès aux membres protégés d'un
autre objet de la classe de base;
 Utilisation de la relation d’amitié si une classe
dérivée souhaite accéder directement aux
membres privés de sa classe de base.

08/12/2019 INSIM TO 55
Destruction des objets dans l’héritage

 Un objet de la classe dérivée est détruit lorsque


sa durée de vie termine.
 Les destructeurs des classes de base et dérivée,
s'ils sont définis, sont invoqués de façon
implicite par le compilateur.
 L'ordre d'invocation des destructeurs pour un
objet de la classe dérivée et l'inverse de l'ordre
d'appel de ses constructeurs.

08/12/2019 INSIM TO 56
Destruction des objets dans l’héritage

 Exemple : destruction d’un objet étudiant

1. Destruction de l’objet
étudiant

Personne

Étudiant
Étudiant

2. Destruction du sous
objet personne

08/12/2019 INSIM TO 57
Le polymorphisme

 Polymorphisme = conséquence de l’héritage en C++


 En C++, le polymorphisme permet d'écrire le noyau
de l'application indépendamment de chacun des types
à manipuler (les classes dérivées).
Principe de substitution
 Le polymorphisme en C++ : un pointeur ou une
référence d'une classe de base peut adresser n'importe
quel objet de ses classes dérivées;
 JAMAIS L'INVERSE !

08/12/2019 INSIM TO 58
Le polymorphisme

 Exemple :On peut créer un objet étudiant via


un pointeur personne :
personne *p = new etudiant ;
p est un pointeur de la classe de base :
personne
 new etudiant; retourne l'adresse d'un objet
etudiant, de classe dérivée

08/12/2019 INSIM TO 59
Conséquence du Polymorphisme

 Ambiguïté du polymorphisme lors de la


réutilisation d’une même désignation de
fonction membre dans les classes de base et
dérivée car :
– Le pointeur est de type de base
– L’objet pointé est de type dérivé

08/12/2019 INSIM TO 60
Conséquence du Polymorphisme
 Exemple : la fonction se_deplacer() dans les classes
personne et étudiant :
class personne {
public :
void se_deplacer () {//à pied}
//...};
class etudiant : public personne {
public :
void se_deplacer () {//par bus}
//...};
 Quelle est la fonction à invoquer dans :
p->se_deplacer();
?
08/12/2019 INSIM TO 61
Conséquence du Polymorphisme

 Solutions :
1. La solution par défaut
2. Les fonctions virtuelles
 La solution par défaut : le compilateur résout
le conflit en imposant que la fonction appelée
soit celle définie dans le type du pointeur (ou
référence);
– Dans notre cas : c'est personne::se_deplacer()
qui sera invoquée;

08/12/2019 INSIM TO 62
Le Polymorphisme et les fonctions virtuelles

 Les fonctions virtuelles : permettent la


sélection de la fonction à invoquer à partir du
type de l'objet et non pas à partir du type du
pointeur (ou référence) qui l'adresse;
 Pour rendre une fonction virtuelle il suffit de
spécifier le mot clé virtual devant sa
déclaration dans la classe de base;

08/12/2019 INSIM TO 63
Le Polymorphisme et les fonctions virtuelles

 Exemple : rendre la fonction se_deplacer() virtuelle :


class personne {
public :
virtual void se_deplacer () {//à pied}
//...
};
 Si la définition de cette fonction est mise à l'extérieur
de la définition de sa classe, le mot clé virtual ne
doit pas être spécifié de nouveau.

08/12/2019 INSIM TO 64
Le Polymorphisme et les fonctions virtuelles
 La classe dérivée peut :
– soit fournir sa propre version de la fonction, qui devient
l'instance active pour cette classe;
– soit hériter de la version de la classe de base.
 Le mécanisme de fonctions virtuelles ne fonctionne
correctement qu'avec les pointeurs et références.
 Le mécanisme virtuel ne permet pas d'appeler une
fonction membre de la classe dérivée non définie
dans sa classe de base
 Les données membres de la classe dérivée ne sont pas
accessibles via un pointeur ou référence vers la classe
de base

08/12/2019 INSIM TO 65
Le polymorphisme et les destructeurs

 Soit le pointeur p :
personne *p = new etudiant;
 p est un pointeur de la classe de base pointant un
objet de la classe dérivée.
 L’instruction : delete (p);
!
 le destructeur de la classe personne qui sera appelé
pour détruire un objet etudiant;
 Donc, il est plus que nécessaire de définir aussi le
destructeur de la classe de base comme étant virtuel.

08/12/2019 INSIM TO 66
Le polymorphisme et les destructeurs

 Règle : Il est recommandé pour la classe de


base, racine d'une hiérarchie de classes
déclarant des fonctions virtuelles, de déclarer
aussi son destructeur comme étant virtuel; ce
dernier ne doit pas être déclaré dans une
section protégée [lippman].

08/12/2019 INSIM TO 67
Héritage multiple

 On se contente généralement d'un héritage public


depuis une seule classe de base.
 Certains cas : nécessité de l'utilisation de l'héritage
multiple;
 La capacité à une classe de dériver de plus d'une seule
classe de base.
 La syntaxe :
– La liste de dérivation qui spécifiera plusieurs classes de
base avec leurs niveaux d'accès séparées par des virgules.

08/12/2019 INSIM TO 68
Héritage multiple
 Exemple : Un amphibien est à la fois un
animal aquatique et terrestre :
Terrestre Aquatique
Membres de la Membres de la
classe terrestre classe aquatique

Amphibien
Membres de la
classe amphibien

08/12/2019 INSIM TO 69
Héritage multiple
 L'implémentation de la classe Amphibien :
class Amphibien : public Aquatique,
public Terrestre
{//... Les membres de classe Amphibien
};
 Une classe de base ne peut apparaître dans une liste
d'héritage multiple que si sa définition a déjà été
fournie
 Pas de limitation du nombre de classes de base qui
peuvent apparaître dans une liste de dérivation
 La classe dérivée contient un sous objet de chacune
de ses classes de base.
08/12/2019 INSIM TO 70
Invocation des constructeurs et destructeurs
 Le processus de création d'un objet d'une classe qui
dérive de plusieurs classes de base est similaire au
processus vu pour l'héritage simple.
 Invocation de tous les constructeurs des classes de
base dans le même ordre de leurs déclarations dans la
liste de dérivation.
1.Création du sous
objet Aquatique

Aquatique Terrestre 2.Création du sous


objet Terrestre
Amphibien
3.Création de l’objet
Amphibien

08/12/2019 INSIM TO 71
Invocation des constructeurs et destructeurs

 L'ordre d'application des destructeurs est


toujours l'inverse de l'ordre d'invocation des
constructeurs.
 Exemple :
3. Destruction du sous
objet Aquatique

Aquatique Terrestre 2. Destruction du sous


objet Terrestre
Amphibien
1. Destruction de l’objet
Amphibien

08/12/2019 INSIM TO 72
Membres hérités de plusieurs classes
 L'accès aux membres (public et protected) dans le cas
d'un héritage multiple est identique à celui vu pour
l'héritage simple.
 Possibilité de conflits lorsqu'on accède à des
membres de même noms qui sont hérités à partir de
plusieurs classes de base.
 Il faut utiliser les noms qualifiés pour rendre l'accès
non ambiguë.
 Les fonctions de même nom héritées à partir de
plusieurs classes de base ne forment pas un jeu de
fonctions surchargées dans la classe dérivée.

08/12/2019 INSIM TO 73
Les fonctions virtuelles et l'héritage multiple

 Les déclarations/définitions virtuelles sont possibles


dans l'héritage multiple.
 Le traitement est identique à celui de l'héritage
simple.
 Lorsqu'un objet de la classe dérivée est alloué via un
pointeur sur un objet de l'une de ses classes de base,
alors les parties spécifiques aux autres classes de base
dans l'objet dérivé ne sont plus accessibles.

08/12/2019 INSIM TO 74
Conséquence de l’héritage multiple
 Exemple : Les classes aquatique et terrestre dérivent
toutes les deux de la classe animal :
Animal
Membres de la
classe animal

Terrestre Aquatique
Membres de la Membres de la
classe terrestre classe aquatique

Amphibien
Membres de la
classe amphibien

08/12/2019 INSIM TO 75
Conséquence de l’héritage multiple

 La classe Amphibien hérite à la fois des classes


aquatique et terrestre  un objet amphibien contient
deux sous objets animal ! Tout accès direct aux membres
de la classe animal à partir de la
classe amphibien cause une
erreur de compilation
Animal
Animal
Aquatique Terrestre
Amphibien

08/12/2019 INSIM TO 76
L’héritage virtuel
 Résolution du problème :
– Si le comportement obtenu par cette forme d'héritage est
celui désiré  utilisation des noms qualifiés pour les accès;
– Sinon  utilisation du mécanisme de l'héritage virtuel.
 Définition : dans l'héritage virtuel un seul sous objet
partagé de la classe de base racine est hérité, quel que
soit le nombre d'apparition de la classe de base dans
la hiérarchie de dérivation.
 La classe de base partagée est dite classe de base
virtuelle

08/12/2019 INSIM TO 77
L’héritage virtuel
 Pour qu'une classe devienne une classe de base virtuelle, il
suffit de faire précéder son nom, dans la liste de dérivation, du
mot clé virtual
 Exemple : Implémentation de l'héritage virtuel ci-dessus :
class animal L'ordre des mots clés public
{//...}; et virtual n'est pas important
class aquatique : public virtual animal
{//...};
class terrestre : virtual public animal
{//...};
class amphibien : public aquatique, public
terrestre
{//...};

08/12/2019 INSIM TO 78
Appel des constructeurs dans d'héritage virtuel

 La règle d’appel : La classe de base virtuelle est


initialisée par sa classe la plus dérivée, déterminée par
la déclaration de chaque objet de classe particulier
[lippman].
 Exemples :
– Lors de la création d'un objet aquatique, le sous objet
animal est initialisé par le constructeur de la classe
aquatique (c'est sa classe la plus dérivée);
– Lors de la création d'un objet amphibien, le sous objet de la
classe animal est initialisé à l'aide du constructeur invoqué
par la classe amphibien.

08/12/2019 INSIM TO 79
Constructeurs/destructeurs dans d'héritage virtuel

 Les objets des classes de base virtuelles sont


toujours construits avant les objets des classes
de base non virtuelles, quel que soit l'endroit
où elles apparaissent dans la hiérarchie
[lippman];
 L'ordre des appels des destructeurs des classes
de base est l'inverse de celui des appels des
constructeurs;

08/12/2019 INSIM TO 80
Fonctions virtuelles pures et classes abstraites
 Une fonction virtuelle pure est une fonction virtuelle
dont le prototype (signature) est suivi d'une
affectation à 0 [lippman];
 La classe qui déclare ce type de fonctions devient
automatiquement une classe abstraite;
 La redéfinition des fonctions virtuelles pures est
obligatoire dans toutes les classes dérivées à partir de
cette classe de base abstraite; Dans le cas contraire,
ces classes dérivées deviennent aussi des classes
abstraites.

08/12/2019 INSIM TO 81
Fonctions virtuelles pures et classes abstraites

 Une fonction virtuelle pure peut ne pas avoir de corps


de définition;
 Il est impossible de créer un objet directement à partir
d'une classe abstraite;
 un objet de classe de base abstraite ne peut exister que
comme un sous objet dans les classes dérivées.
 Tenter d’invoquer une fonction virtuelle pure
provoque une erreur de compilation (on ne doit
invoquer que l'instance redéfinie);

08/12/2019 INSIM TO 82
Fonctions virtuelles pures et classes abstraites

 Exemple : définir la fonction membre se_deplacer()


dans la classe animal :
Fonction virtuelle pure
class animal {
virtual void se_deplacer () = 0;
//suite de la classe
};
class aquatique : public virtual animal {
void se_deplacer () { //nager }
};
class terrestre : virtual public animal {
void se_deplacer () { //marcher }
};

08/12/2019 INSIM TO 83
La composition
 L'héritage public étudié fournit une implémentation d'une
relation de sous typage : "est un" basée sur le concept
généralisation/spécialisation;
 C++ permet l’implémentation de la relation qui exprime la
composition entre objets : "possède un" basée sur le concept
de composant/composé ou d’agrégation;
– Exemple : Un ordinateur est composé d'UC, de mémoire, et de
périphériques;
 La composition est implémentée en rendant une classe
membre d'une autre classe [lippman]; Il existe deux formes de
composition d'objets en C++ :
– La composition par valeur
– La composition par référence.

08/12/2019 INSIM TO 84
La composition par valeur
 C'est l'implémentation de la relation d'agrégation
 Un objet réel de la classe composant est déclaré en
tant que membre de la classe composée;
 Exemple :
class UC
{//...};
Objet de la classe UC comme
class ordinateur données membres de la classe
{//... ordinateur
UC unit;
//…
};

08/12/2019 INSIM TO 85
La composition par valeur

 Gestion automatiquement de la durée de vie de l'objet


contenu ainsi que les sémantiques de copie et
d'affectation tout en offrant un accès direct à l'objet;

 L'inconvénient : la perte en efficacité lorsque les


objets contenus sont issus de classes de taille
importante et que plusieurs copies et/ou affectations
sont effectuées dans le programme.

08/12/2019 INSIM TO 86
La composition par référence

 C'est l'implémentation de la relation d'association


entre classes.
 Un objet de la classe composant est adressé
indirectement via un pointeur, ou une référence, dans
la classe contenant. Pointeur vers un objet de la
classe
 Exemple : la liste des logiciels Logicielsur
installés comme
un données
membres de la classe ordinateur
ordinateur :
class ordinateur {
Logiciel* list_log;
};

08/12/2019 INSIM TO 87
Programmation orientée objet
en C++
Chapitre 3 : La programmation générique
Auteur : N. TAMANI
La programmation générique
 La généricité est un mécanisme de programmation
qui permet d’implémenter des modules (fonctions ou
classe) indépendamment des types de données.
 Le but du chapitre : prendre connaissance des bases
de la programmation génériques
 Les modèles (patron ou template) de fonctions
 Les modèles de classes.
 Présentation de la STL (Standard Template Library).

08/12/2019 INSIM TO 89
Les patrons de fonctions
 Un patron de fonctions est un mécanisme qui fournit
une gestion automatique des instances particulières
d'une fonction variant selon le type.
 un patron de fonctions est un générateur de fonctions
qui réalisent toutes le même traitement mais sur des
types de données différents.
 Le patron de fonctions est une généralisation d’un
traitement; l’instance du patron est une application du
traitement à un type (ou ensemble de types) de
données particulier(s).

08/12/2019 INSIM TO 90
Les patrons de fonctions
 Exemple : la fonction max()
– Elle peut s’appliquer de façon identique sur des valeurs
entières, doubles, de type string et même sur des objets de
classe surchargeant l'opérateur de test (généralement
l'opérateur supérieur à >).
– La fonction max() peut se définir comme étant un patron de
fonction.
int max (int a, int b)
{ if (a>b) return a; return b;}
T max (T a, T b)
double max (double a, double b) {
{ if (a>b) return a; return b;}
= if (a>b) return a;
return b;
string max (string a, string b) }
{ if (a>b) return a; return b;}

08/12/2019 INSIM TO 91
Déclaration/définition d'un patron de fonctions
 Syntaxe :
template <liste_param_type>
//declaration/definition du patron.
 template : mot clé du langage pour introduire un modèle de
classe;
 list_param_type : la liste des paramètres du patron de la
forme :
class ident ou typename ident séparées par des virgules, ou
encore type_real ident;
 class et typename étant des mots clés du langage qui
introduisent ident comme étant un paramètre de type;
 type_real un type simple ou composé prédéfini ou défini par
l'utilisateur qui introduit ident comme un paramètre de valeur
du patron;

08/12/2019 INSIM TO 92
Déclaration/définition d'un patron de fonctions
 Exemple : le patron de fonction max() déclaré comme suit :
template <typename T>
T max ( T, T);
– max() est un patron de fonction qui accepte deux arguments de type T
et retourne une valeur de type T;
 La définition du patron de fonction max () :
template <typename T>
T max ( T a, T b)
{
if (a > b) return a;
return b;
}
 Le programmeur peut paramétrer tous les types, ou un sous
ensemble des types, dans l'interface (type retour + signature)
du patron de fonctions

08/12/2019 INSIM TO 93
Les paramètres d’un patron de fonctions
 On peut avoir comme paramètre de patron un paramètre non
type; ce nom correspond alors à une valeur transmise au patron
de la fonction.
• La référence pour tab est
 Exemple : obligatoire
template <class T, int size> • size est la taille de tab;
void affiche (T (&tab) [size]);
 Un identificateur utilisé pour spécifier un paramètre de patron
garde ce statut tout le long de la déclaration/définition du
patron :
 Il cache toute déclaration/définition d'objet, classe, type, fonction, etc.
apparaissant dans les portées englobant la déclaration/définition du
patron de fonction.
 Toute déclaration/définition d'objets, ou type à l'intérieur de la
définition d'un patron ne doit pas avoir un nom identique à l'un des
identificateurs utilisés pour spécifier un paramètre de ce patron

08/12/2019 INSIM TO 94
Les paramètres d’un patron de fonctions
 Les identificateurs doivent être uniques à l'intérieur
de la liste des paramètres du patron.
 Exemple : le code suivant est faux, car T est spécifié
deux fois dans la liste de paramètres :
template <class T, class T>
//suite de la déclaration du patron x
 Un identificateur utilisé pour spécifier un paramètre
de patron peut être réutilisé pour spécifier un
paramètre de patron dans d'autres déclarations et/ou
définitions de patrons;

08/12/2019 INSIM TO 95
Les paramètres d’un patron de fonctions
 Les noms de paramètres de patron n'ont pas besoin
d'être identiques entre la déclaration et la définition
d’un même patron.
 Pas de contrainte de nombres d'apparition d'un nom
de paramètre de patron dans la liste de paramètres de
la fonction;
 Un patron de fonctions peut aussi être déclaré inline
ou extern;
 le mot clé inline (ou extern) ne se mettra pas avant le mot clé
template mais il sera placé devant le type retour du patron :
 Exemple :
template <class T>
inline T min (T, T);

08/12/2019 INSIM TO 96
Instanciation de patron de fonctions
 Définition : L'instanciation de patron de classe
est la façon avec laquelle les fonctions
individuelles sont construites en précisant des
types et/ou des valeurs réelles en
remplacement des paramètres du patron source
des fonctions;
 L'instanciation est effectuée par le compilateur
de façon implicite lorsqu'on fait appel au
patron à l'aide d'arguments de type réels :
 Processus dé déduction d’arguments de patron

08/12/2019 INSIM TO 97
Instanciation de patron de fonctions
 Exemple : l'instanciation du patron max () est
effectuée à chaque ligne du code où un appel à max()
est invoqué :
Instancier la fonction :
int a = 10, b = 30; int max (int, int); puis
int m = max (a, b); l'invoquer

string str1 = "plan"; Instancier la fonction :


string max (string, string);
string str2 ="plat"; puis l'invoquer
string max_str
= max (str1, str2);

08/12/2019 INSIM TO 98
Arguments de patron explicites
 Soit l'appel suivant :
long int li;
cout << max (li, 3) << endl; x
 Le processus de déduction d'arguments ne pourra pas
instancier une fonction max (long int, int)
 Incapacité de trouver la fonction à appeler 
spécification d'arguments explicites;
 La syntaxe est comme suit :
nom_patron <liste_types_réels> (liste_argument_fonction);
 liste_types_réels : liste de types réels séparés par des
virgules; chaque type dans cette liste correspond à un
paramètre de type du patron;

08/12/2019 INSIM TO 99
Arguments de patron explicites
 Exemple : Instancier le patron max() avec les
arguments li et 3 :
 on doit passer par une fonction de spécification
explicite d'arguments :
max<long int> (li, 3);
 Le compilateur instanciera directement la fonction
max(long int, long int); sans passer par la déduction
d'arguments.
 Il n'est pas obligatoire de fournir pour chaque
paramètre de type un argument explicite dans la liste
d'arguments explicites;
 Les arguments qui peuvent être déduits de façon
implicite ne nécessitent pas d'arguments explicites;
08/12/2019 INSIM TO 100
Arguments de patron explicites
 On respectera alors la même règle vue pour les arguments par
défaut pour une fonction :
 on ne peut omettre que les arguments les plus à droite.
 Il existe une autre situation où l'utilisation d'arguments de
patron explicites est inévitable :
template <class T1, class T2>
T1 fct (T2);
 Lors de l'appel de la fonction avec un type donné, la déduction
d'argument n'a pas la possibilité de déduire le type réel à
affecter à T1;
 on doit impérativement passer par les arguments de patron
explicite : Instancier la fonction :
fct <int> (3.14); int fct (double); puis l'invoquer

08/12/2019 INSIM TO 101


Les patrons de classe
 Un patron de classe est pour une classe instance ce
qu'un patron de fonctions est pour une fonction
instance.
 Un Patron de classe permet de programmer de façon
générique en paramétrant un ou plusieurs types des
données et/ou des fonctions membres d'une classe.
 Le patron de classe devient alors une source à partir
de laquelle on peut créer des classes qui sont, à leur
tour, source des objets manipulés dans le programme.

08/12/2019 INSIM TO 102


Déclaration/définition d'un patron de classe
 Syntaxe de déclaration d’un patron de classe :
template <liste_param_type> class nom_patron;
 liste_param_type : est une séquence de la forme :
– class nom_param ou bien
– typename nom_param ou encore
– des paramètres non typés
 Séparés par des virgules.
 Les nom_param introduits par les mots clés typename ou
class seront utilisés pour spécifier des types dans la définition
du patron.
 Un paramètre non type correspond à une déclaration de
paramètre ordinaire;

08/12/2019 INSIM TO 103


Déclaration/définition d'un patron de classe
 Des paramètres d'un patron (type ou non) peuvent
recevoir une valeur par défaut;
 Il faut respecter les mêmes contraintes vues pour les
arguments par défaut des fonctions ordinaires.
 En plus des contraintes vues pour les paramètres de
patron de fonctions, les paramètres d'un patron de
classe doivent aussi respecter la contrainte suivante :
– Un nom de paramètres ne doit pas être utilisé pour déclarer
une donnée ou une fonction membre du patron ;
 Dans la définition d'un patron de classe, le nom du
patron peut être utilisé partout ou un type est utilisé
(exemple de définition d'un patron classe récursif).

08/12/2019 INSIM TO 104


Déclaration/définition d'un patron de classe

 Un patron de classe se définit de la même manière qu’un


patron de fonction.
 Exemple : définition du patron de classe array qui implémente
un tableau d'éléments de n'importe quel type et taille, et ayant
aussi pour paramètres non type un entier spécifiant sa taille :
template <typename T, unsigned int taille>
class array {
public :
array () : size (taille) {}
private :
unsigned int size;
T vect [taille];
};

08/12/2019 INSIM TO 105


Instanciation d'un patron de classe
 L'instanciation d'un patron de classe est le processus
par lequel une classe est créée à partir de la définition
du patron de classe générique.
 Le processus réalise des substitutions des paramètres
du patron par un ensemble de types ou valeurs fournis
en argument de l'instanciation.
 L'instanciation du patron se fait implicitement
lorsqu'on crée un objet à partir du patron.

08/12/2019 INSIM TO 106


Instanciation d'un patron de classe
 Syntaxe d’instanciation :
nom_patron <liste_arguments> nom_objet;
 liste_arguments : la liste des types et/ou valeurs
réels qui serviront à la substitution des paramètres du
patron de classe.
 Exemple : instancier un array d’entier à 20 cases :
array<int, 20> v;

class array { template <T, int taille>


public : class array {
array () : size (20) {} public : array:v
private : array () : size (taille) {}
unsigned int size; private :
int vect [20]; unsigned int size;
}; T vect [taille];
};

08/12/2019 INSIM TO 107


Les arguments des paramètres non type
 L'expression associée à un paramètre non type doit
être constante :
int x = 20;


array <int, x> v;
Corriger cette erreur :
x
const int x = 20;
array <int, x> v;
 Le compilateur l'adresse d'un objet membre d'espace
de noms ainsi que le résultat de l'expression sizeof()
sont des expressions constantes.

08/12/2019 INSIM TO 108


Fonctions membres de patron de classe

 Définition d’une fonction membre à l’extérieur du


patron dans lequel elle est définie :
template <liste_param> type_retour
nom_patron <liste_arg>::nom_fonction
(param_fonction)
{/*le corps de définition*/}
 liste_param : la liste des paramètres du patron, c'est-
à-dire la liste class Type ou typename Type ou encore
type ident;
 list_arg : la liste des Types et/ou idents utilisés dans
la liste des paramètres du patron;

08/12/2019 INSIM TO 109


Fonctions membres de patron de classe
 Exemple : ajouter au patron array une fonction membre
getsize() qui retourne la taille du tableau :
template <typename T, int taille>
class array {
public :
int getsize(); //déclaration de la fonction
getsize();
//... suite du corps de array
};
 La définition de la fonction membre getsize() à l'extérieur du
patron est comme suit :
template <typename T, int taille>
int array<T, taille>::getsize()
{return size;}

08/12/2019 INSIM TO 110


Présentation de la bibliothèque STL
 La STL est une bibliothèque de patrons de classes et
un ensemble d'algorithmes génériques qui facilitent la
déclaration et la manipulation des types abstraits de
données.
 Mise à disposition d’une gamme de types génériques
dont l'utilisation nécessite une connaissance assez
consistante des patrons et de la programmation
générique.
 Les types de la STL sont :
– Les conteneurs d'objets (list, vector,...)
– L'abstraction des pointeurs : les itérateurs.

08/12/2019 INSIM TO 111


Les conteneurs de séquences
 Ce sont des abstractions des types de données qui stockent
séquentiellement en mémoire les objets contenus.
 vector : abstraction d'un tableau, les accès peuvent être
aléatoires et les ajouts/suppressions se font en un temps stable
à la fin du conteneur.
 list : abstraction d'une liste chaînée.
 queue : abstraction d'une file FIFO (First In First Out).
 deque : c'est un vector dans lequel les fonctions d'accès et de
suppressions opèrent sur les deux côtés du conteneur (ie début,
et fin). Elles se font en un temps stable.
 stack : abstraction d'une pile.

08/12/2019 INSIM TO 112


Les conteneurs associatifs
 Ce sont des types qui associent des clés d'indexations
aux valeurs stockées.
 set : est l'abstraction d'un ensemble.
 map : équivalent à une table associative à
correspondance <clé, valeur>, l'objet valeur est
indexé par la clé fournie.
 Ces types ont aussi une version multi-valeurs, ie ils
permettent la duplication d'une même valeur dans le
conteneur.

08/12/2019 INSIM TO 113


Les itérateurs ou iterators
 Un itérateur (ou iterator) est l’abstraction d’un
pointeur.
 Chaque conteneur possède ses itérateurs pour pouvoir
itérer sur les objets contenus et réaliser des accès ou
des modifications. it est un itérateur défini sur
 Exemple : définir un itérateur surle un objetvector
conteneur vector
<int>
d’entier :
vector <int> v;
vector<int>::iterator it;
 Ils sont l'intermédiaire entre les conteneurs et les
algorithmes qui les manipulent.

08/12/2019 INSIM TO 114


Les itérateurs ou iterators
 forward iterator : fournit un sens unique de parcours des
éléments d'une séquence (en avant par l'opérateur ++) .
 bidirectionnal iterator : fournit les deux sens de parcours des
éléments d'une séquence (par les opérateurs ++ et --).
 random acces iterator : fournit des itérateurs qui peuvent être
manipulés dans des expressions arithmétiques et logiques;
donc capables de réaliser tous les déplacements possibles.
 input iterator : est un forward iterator dont le rôle est
uniquement la lecture d'une valeur d'un conteneur.
 output iterator : est un forward iterator dont le rôle se limite
à l'écriture d'une valeur dans un conteneur.

08/12/2019 INSIM TO 115


Les algorithmes génériques
 La STL définit aussi un certain nombre d'algorithmes dits
génériques afin de manipuler les objets, instances de ces types.
 Ces algorithmes sont généraux et s'adaptent à presque tous les
conteneurs.
 Dans la version de la STL incluse dans le compilateur C++
version 3.0, on peut dénombrer plus d'une soixantaine
d'algorithmes.
 En plus d'autres paramètres, un algorithme générique reçoit
généralement une paire d'itérateurs : first et last qui
déterminent l'intervalle des éléments (intervalle gauche
inclusif désigné par [first, last))dans le conteneur sur lequel
opérer.

08/12/2019 INSIM TO 116


Quelques algorithmes génériques
 find() : cherche la première occurrence de l'élément, fourni en
argument, dans l'intervalle [first, last).
 Si l'élément existe dans l'intervalle, alors un itérateur indiquant sa
position est retourné, sinon last est retourné.
 find_if() : Idem, sauf que le test est effectué par un prédicat
donné en argument
 min(), max() : retourne le plus petit (resp. le plus grand), selon
l'opérateur '<' (resp. '>') associé au type des deux éléments
fournis en argument.
 Ces deux algorithmes possèdent une autre version qui permet de
préciser l'opérateur de test à utiliser à la place de '<' (resp. '>').
 sort() : assure un tri croissant des éléments de l'intervalle
[first, last) via l'opérateur '<' du type concerné.
 Une version qui permet de réaliser le tri selon un autre opérateur est
aussi fournie.

08/12/2019 INSIM TO 117


Utilisation des types STL dans un programme
 Les types de la STL nécessitent l'inclusion des
fichiers en-têtes lors de leurs utilisations.
 Chaque type a son header spécifique qui porte la
même désignation que le type considéré.
 Exemple : pour utiliser les types list et vector, il faut
inclure les fichiers <list> et <vector>.
 La déclaration d'un objet conteneur oblige l'utilisateur
à fournir un (ou plusieurs) type(s) concret(s) pour
l'instanciation de(s) paramètre(s) de type.
 Les types concrets doivent supporter les opérateurs
"=" et "<" et une valeur par défaut.
08/12/2019 INSIM TO 118
Utilisation des types STL dans un programme

 Pour utiliser les algorithmes génériques (non


numériques), il est nécessaire d'inclure le fichier d'en-
tête : <algorithme>.
 Les algorithmes numériques comme accumulate(),
inner_product(), adjacent_difference(), et
partial_sum() nécessitent l'inclusion du fichier d'en-
tête : <numeric>.

08/12/2019 INSIM TO 119


Bibliographie

 Stanley B. Lippman et Josée Lajoie.


L'essentiel du C++. 3ème édition. Vuibert
2000.
 Rensselear Polytechnic Institute. Standard
Template library Reference. 1994.
 Jesse Liberty. C++ Ressources d’experts.
Compus Press. 1999

08/12/2019 INSIM TO 120

Vous aimerez peut-être aussi