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/19 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
{
corps de la classe
string nom;
string prenom;
...}
;
08/12/19 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 {
nom, prenom, age sont les
string nom; données membres de la
string prenom; classe personne
short int age;
};
08/12/19 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/19 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
membres de la
class personne { classe
...//les données membres de la classe
string getNom();
string getPrenom();
string getAge() {return age;}
};
08/12/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 INSIM TO 30
 Exemples de constructeurs
 Exemple : Soit la classe personne suivante :
class personne {
public :
string nom;
string prenom;
Le constructeur par défaut
int age;
personne () { }
personne (string str_n, string str_p, int i)
{
nom = str_n;
prenom = str_p; Le constructeur avec
age = i; arguments
}
};

08/12/19 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
donnée membre Le constructeur avec
string prenom; 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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
Personne

Étudiant

2. Création de l’objet
étudiant

08/12/19 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/19 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/19 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
//...};
constructeur avec
class etudiant : public personne {arguments de la classe
public : personne
int anne_etud;
etudiant (string ne, string pe, int ae, int
anne) :
personne (ne, pe, ae),
anne_etud (an) { }
//...};

08/12/19 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
redéfinie dans la classe dérivée
public :
void se_deplacer () {//à pied}
//...};
class etudiant : public personne {
public :
void se_deplacer () {//par bus}
//...};

08/12/19 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/19 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/19 INSIM TO 56
 Destruction des objets dans l’héritage

 Exemple : destruction d’un objet étudiant

1. Destruction de l’objet
étudiant

Personne
Personne

Étudiant
Étudiant

2. Destruction du sous
objet personne

08/12/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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

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

08/12/19 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

Aquatique Terrestre objet Terrestre
Amphibien
1. Destruction de l’objet
Amphibien

08/12/19 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/19 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/19 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/19 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
Aquatique Terrestre
Amphibien

08/12/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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 Logiciel comme données
 Exemple : la liste des logiciels installés sur un
membres de la classe ordinateur
ordinateur :
class ordinateur {
Logiciel* list_log;
};

08/12/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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
l'invoquer
int m = max (a, b);
Instancier la fonction :
string str1 = "plan"; string max (string, string);
string str2 ="plat"; puis l'invoquer
string max_str
= max (str1, str2);

08/12/19 INSIM TO 98
 Arguments de patron explicites
 Soit l'appel suivant :

x
long int li;
cout << max (li, 3) << endl;
 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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/19 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
conteneur vector <int>
objet vector
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/19 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/19 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/19 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/19 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/19 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/19 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/19 INSIM TO 120