Introduction 2

 C++ est un langage impératif supportant les

concepts objet.

 C++ est conçu/implémenté par B. Stroustrup,

aux laboratoires Bell AT&T, vers 1983.

 C++ s’inspire essentiellement des langages C

et Simula67.

 C++ reprend la plupart des définitions du

langage C.
 Introduction 3

 C++ est très répondu auprès des développeurs

d’applications. Pourquoi ?

1. Compatible avec le langage C

2. Contrôle du type d'arguments d'une fonction
3. Passage de paramètres de la fonction par référence

4. Influencé par Simula 67 avec l'apport des classes

5. Prise en charge des concepts orientés objet

 Introduction 4

 C++ est standardisé à partir de 1989 par ISO

C Typage fort Classes

C++

 C++ autorise la programmation procédurale

 Structure d’un programme 5

 Directives de compilation
#include <iostream.h> // répertoire standard de fichiers
#include "mabiblio.h" // fichier ou module stocké ailleurs

 Déclaration globales
const float PI = 3.14159 ; // [variables ou foncions]

 Suite de fonctions
void lire_annee(int annee) {
/* … instructions et structures de contrôle */ }

 Programme principal
void main()
{ /* … construction d’objets & messages … */ }
 Fonctions 6

 Déclaration d'une fonction (prototype)

typeRésultat identiFonction(type1 param1, type2 param2, …) ;

 Définition d'une fonction (en-tête + corps)

int max(int a, int b, int c)
{ int m = (a > b) ? a : b ;
return (m > c) ? m : c ; }

 Appel d'une fonction

int nb1, nb2, sup ;
sup = max(nb1, nb2*10, 1000) ; // appel de la fonction
 Fonctions 7

 Passage de paramètres par valeur

(typeParam identiParam, …) /* utilisé par la fonction pour
recevoir des infos de l'extérieur */

 Passage de paramètres par référence (alias)

(typeParam & identiParam, …) /* une référence est un nom
alternatif ou alias pour un objet */
void
void main()
main() {{ int
int
i=1
i=1 ;;
int
int &
& rr == ii ;; //// déclaration
déclaration de de variable
variable référence
référence
rr alias de ii r++
alias de r++ ;; //// ii est
est aussi
aussi incrémentée
incrémentée de
de
11
cout
cout <<i
<<i <<"
<<" "" <<r
<<r ;; }} //// affichage
affichage :: 22 22
 Fonctions 8

 Fonctions compilées en ligne (inline)

inline typeRésultat identiFct(type1 Param1, … )
{ /* … un corps court */ } // pour gagner du temps exécution

 Surcharge de fonctions

void
void affiche(int
affiche(int nb)
nb) {{ printf("%d\n",
printf("%d\n", nb
nb ;; }}
void
void affiche(float
affiche(float nb)
nb) {{ printf("%.2f\n",
printf("%.2f\n", nb
nb ;; }}
//// 22 définitions
définitions différentes
différentes de
de la
la fonction
fonction affiche()
affiche()
void
void main()
main() {{
int
int i=4
i=4 ;; float
float x=10.5
x=10.5 ;;
affiche(i)
affiche(i) ;; //// affichage
affichage d'un
d'un entier
entier
affiche(x)
affiche(x) ;; }} //// affichage
affichage d'un
d'un réel
réel
 Classes & Objets 9

 Exemple : Mouvements et Interactions de Planètes

Mercure
Terre
Vénus Soleil

 Pour la simulation ? Faire des abstractions !

 Classes & Objets 10

 Abstraction de Données et Classes

Description et
comportement de la Planete
notion planète

Membres Membres
données fonctions
- Déclaration : données + prototypes fonctions
- Définition des fonctions de la classe.
 Classes & Objets 11

 Déclaration de la classe Planete

Class
Class Planete
Planete {{
Public
Public ::
void
void definition(void)
definition(void) ;; //// saisie saisie
void
void deplacer(float)
deplacer(float) ;; //// mise
mise àà jour
jour
void
void position(void)
position(void) ;; //// affichage
affichage des
des données
données
Private
Private ::
char
char nom[20]
nom[20] ;; //// nom
nom
float
float vitesse
vitesse ;; //// vitesse
vitesse orbitale
orbitale
float
float distance
distance ;; //// distance
distance au au soleil
soleil
float
float oldX,
oldX, oldY
oldY ;; //// ancienne
ancienne position
position
float
float X,
X, YY ;; //// position
position actuelle
actuelle
void
void trace(void)
trace(void) ;; /*
/* mémoriser
mémoriser position
position actuelle
actuelle /*
/* }} ;;
 Classes & Objets 12

 Encapsulation de membres
- Tout programme utilisant un objet d'une certaine classe
ne peut accéder qu'aux membres publics ;
- Les membres privés d'une classe ne sont accessibles qu'à
l'intérieur de cette classe.
notre
exemple - Ce mécanisme, qui empêche l'accès direct à des
membres privés, s'appelle l'encapsulation.

Tout utilisateur de la classe Planete ne pourra manipuler l'un

des membres privés comme vitesse ou trace que par
l'intermédiaire des méthodes publiques comme definition,
deplacer ou position.
 Classes & Objets 13

 Définition d'une fonction membre

typeRésultat nomClasse :: nomFonction(type1 param1, …)
{ /* …instructions */ }

Opérateur de résolution de portée

 Définition de la fonction trace() (peut être inline)

inline
inline void
void Planete::trace(void)
Planete::trace(void) //// mémoriser
mémoriser position
position actuelle
actuelle
{{ oldX
oldX == X
X ;; //// accès
accès direct
direct autorisé
autorisé aux
aux données
données privées,
privées,
oldY
oldY == Y
Y ;; //// seulement
seulement àà l'intérieur
l'intérieur de
de la
la classe
classe Planete
Planete
}}
 Classes & Objets 14

 Définition de la fonction definition()

void
void Planete::definition(
Planete::definition( void
void ))
{{ cout
cout <<"Nom
<<"Nom planète:
planète: "" ;; cin>>nom
cin>>nom ;;
cout
cout <<"Vitesse
<<"Vitesse orbitale:
orbitale: "" ;; cin>>vitesse
cin>>vitesse ;;
cout
cout <<"Distance
<<"Distance auau soleil:
soleil: "" ;; cin>>distance
cin>>distance ;;
cout
cout <<"Position
<<"Position actuelle(X):
actuelle(X): "" ;; cin>>X
cin>>X ;;
cout
cout <<"Position
<<"Position actuelle(Y):
actuelle(Y): "" ;; cin>>Y
cin>>Y ;;
trace()
trace() ;; }}

 Définition de la fonction deplacer()

void
void Planete::deplacer(
Planete::deplacer( float
float tt ))
{{ trace()
trace() ;; //// mémoriser
mémoriser position
position actuelle
actuelle
/*…
/*… calcul
calcul nouvelle
nouvelle position
position avec
avec t,t, vitesse
vitesse et
et distance
distance */
*/ }}
 Classes & Objets 15

 Définition de la fonction position()

void
void Planete::position(void)
Planete::position(void)
{{ cout
cout <<"Planète:
<<"Planète: "" <<nom
<<nom <<"\n"
<<"\n" ;;
cout
cout <<"Ancienne
<<"Ancienne position
position (x,y)
(x,y) :: "" <<oldX
<<oldX <<","
<<"," <<oldY
<<oldY ;;
cout
cout <<"Nouvelle
<<"Nouvelle position
position (x,y)
(x,y) :: "" <<X
<<X <<","
<<"," <<Y
<<Y <<"\n"
<<"\n" ;;
}}

 Création 2 objets : mercure et venus

Planete
Planete merure,
merure, venus
venus ;;
/*
/* Ces
Ces objets
objets peuvent
peuvent accéder
accéder àà leurs
leurs membres
membres publics
publics en
en
utilisant
utilisant l'opérateur
l'opérateur point
point (.)
(.) */
*/
 Classes & Objets 16

 Constructeur sans paramètres

class
class Planete
Planete
{{ public
public ::
Planete(void)
Planete(void) ;; //// constructeur
constructeur sans
sans paramètres
paramètres
//// …
… autres
autres membres
membres publics
publics
private
private ::
//// …
… membres
membres privés
privés
};
};
#include
#include <string>
<string>
Planete::Planete(void)
Planete::Planete(void) //// définition
définition du
du constructeur
constructeur par
par défaut
défaut
{{ strcpy(nom,
strcpy(nom, "" ") ") ;;
distance=0
distance=0 ;; vitesse=0
vitesse=0 ;; X=0
X=0 ;; Y=0
Y=0 ;;
trace()
trace() ;; }}
 Classes & Objets 17

 Constructeur avec paramètres

class
class Planete
Planete
{{ public
public ::
Planete(char
Planete(char *nm,
*nm, float
float dis,
dis, float
float vit,
vit, float
float x,
x, float
float y)
y) ;;
//// …
… autres
autres membres
membres publics
publics
private
private ::
//// …
… membres
membres privés
privés
};
};
#include
#include <string>
<string>
Planete::Planete(char
Planete::Planete(char *nm,
*nm, float
float dis,
dis, float
float vit,
vit, float
float x,
x, float
float y)
y)
{{ strcpy(nom,
strcpy(nom, nm)nm) ;;
distance=dis
distance=dis ;; vitesse=vit
vitesse=vit ;; X=x
X=x ;; Y=y
Y=y ;;
trace()
trace() ;; }}
 Classes & Objets 18

 Destructeur
Fonction appelée automatiquement par le programme
pour détruire l'objet dont la durée de vie se termine.

class
class Planete
Planete
{{ public
public ::
~Planete(void)
~Planete(void) //// prototype
prototype fonction
fonction destructeur
destructeur d'objets
d'objets
//// …
… membres
membres publics
publics (y(y compris
compris constructeur)
constructeur)
private
private ::
//// …
… membres
membres privés
privés
}} ;;
Planete::
Planete:: ~Planete(void)
~Planete(void) //// définition
définition du
du destructeur
destructeur d'objets
d'objets
{{ cout
cout <<"La
<<"La planète
planète "" <<nom
<<nom <<" <<" aa été
été détruite
détruite !! \n"
\n" ;; }}
 Classes & Objets 19

 Séparer déclaration, définition et utilisation

PLANETE.H
class Planete
fichier en-tête : déclarations
{ /* … structure classe */ } ;
des classes (modélisation).

#include "Planete.h" PLANETE.CPP

void Planete::definition(void) fichier définitions
{ /* … instructions */ } ; des classes (méthodes).
// … autres méthodes

#include "Planete.h"
ASTRO.CPP
void main()
fichier d'utilisation
{ Planete pluton ;
des classes (programme).
/* … suite programme */ } ;
 Classes & Objets 20

 Tableau d'objets

Déclaration d'un tableau de 9 objets type Planete

Planete systemeSolaire[9] ;

9 objets Planete invoquant la méthode definition()

systemeSolaire[0].definition() ; // 1er objet du tableau

systemeSolaire[1].definition() ; // 2ème objet du tableau

…
systemeSolaire[8].definition() ; // 9ème objet du tableau
 Classes & Objets 21

 Fonction amie

multiplie() fonction amie (indépendante)

Matrice Vecteur
mat[3][3] Privé vect[3]

class
class Matrice
Matrice class
class Vecteur
Vecteur
{{ //// …
… {{ //// …
…
friend
friend Vecteur
Vecteur multiplie(…)
multiplie(…) ;; }} friend
friend Vecteur
Vecteur multiplie(…)
multiplie(…) ;; }}

 Une fonction amie peut être aussi membre d'une des deux
classes et être déclarée amie de l'autre ( page suivante ), …
 Classes & Objets 22

 Classes amies
Méthode d'une classe amie d'une autre classe

class
class A A ;;
class
class B B {{ //// …
…
void
void acces(
acces( A A& & param1,
param1, …)
…) ;; }} ;;
class
class A A
{{ friend
friend B::acces(
B::acces( A A& & param1,
param1, …)…) ;;
//// …
… }} ;; //// acces()
acces() est
est une
une méthode
méthode de
de B B ;; elle
elle est
est amie
amie de
de A
A

Classe amie d'une autre classe

class
class BB {{ //// …
… }} ;;
class
class AA
{{ friend
friend class
class B
B ;; }} ;; //// toute
toute méthode
méthode de
de B
B est
est amie
amie de
de A
A
 Classes & Objets 23

 Surcharge d'opérateurs
typeResultat operatorop(paramètres) ; // prototype fonction opérateur

mot-clé Symbole de l'opérateur surchargé

Tous les opérateurs de C++ peuvent être surchargés à l'exception de

la liste suivante : . .* :: ?: sizeof # ##

Soit une classe Vendeur, contenant operator+ , on peut écrire :

Vendeur region, omar, salim ; // déclaration de 3 objets
region = omar + salim ; // region = omar.operator+(salim)
 Classes & Objets 24

 Surcharge du + pour la classe Vecteur

class
class Vecteur
Vecteur ;; //// vecteur
vecteur des des entiers
entiers àà 22 dimensions
dimensions
{{ public
public ::
Vecteur(int
Vecteur(int x, x, int
int y)
y) ;;
Vecteur
Vecteur operator+(
operator+( Vecteur Vecteur & & bb )) ;;
//// …
… }} ;;
Vecteur
Vecteur Vecteur::operator+(
Vecteur::operator+( Vecteur Vecteur & & bb ))
{{ double
double sx, sx, sy
sy ;;
sx
sx == xx ++ b.lectureX()
b.lectureX() ;; //// x,yx,y :: données
données privées
privées de
de Vecteur,
Vecteur,
sy
sy == yy ++ b.lectureY()
b.lectureY() ;; //// et
et lecture?()
lecture?() :: méthodes
méthodes publiques
publiques
Vecteur
Vecteur sum(sx,
sum(sx, sy) sy) ;; //// déclaration
déclaration avecavec initialisateur
initialisateur
return
return sum sum ;;
}} ;;
 Classes & Objets 25

 Encapsulation à base de classes

En C++ , une fonction membre d'une classe peut accéder
directement aux membres privés de n'importe quelle instance de
cette classe (objet).

Ainsi, selon ce principe, operator+ de la classe Vecteur sera

programmé comme suit :

Vecteur
Vecteur Vecteur::operator+(
Vecteur::operator+( Vecteur&
Vecteur& bb ))
{{ //// …
…
sx
sx == xx ++ b.x
b.x ;; //// x,y
x,y :: données
données privées
privées de
de
Vecteur
Vecteur sy
sy == yy ++ b.y
b.y ;; //// accès
accès direct
direct àà (x,
(x, y)
y)
du
du vecteur
vecteur bb
//// …
…
}} ;;
 Classes & Objets 26

 Donnée statique
Rattachée à une classe (1 exemplaire) et partagée par tous les
objets de la même classe.

Initialisée explicitement à l'extérieur de la classe (fichier définition),

même si elle est privée.

class
class Epargne
Epargne //// Gestion
Gestion de
de carnets
carnets d'épargne
d'épargne
{{ static
static float
float taux
taux ;;
/*
/* …
… autres
autres déclarations
déclarations de
de la
la classe
classe */
*/ }} ;;
//// et
et dans
dans le
le fichier
fichier de
de définition
définition de
de la
la classe
classe on
on initialise
initialise ::
float
float Epargne::taux
Epargne::taux == 4.75
4.75 ;; OU
OU
float
float
Epargne::taux(4.75);
Epargne::taux(4.75);
 Classes & Objets 27

 Fonction statique
Elle a une action indépendante d'un quelconque objet. Elle est
appelée sans mentionner un objet particulier (juste la classe).

Elle ne peut accéder directement qu'aux membres statiques :

données ou fonctions.

class
class Epargne
Epargne //// Gestion
Gestion de
de carnets
carnets d'épargne
d'épargne
{{ static
static float
float taux
taux ;;
public
public ::
static
static void
void changeTaux(float
changeTaux(float nouv)
nouv) {{ taux
taux == nouv
nouv ;; }} ;;
};
};
//// Exemple
Exemple d'utilisation
d'utilisation dans
dans le
le main()
main()
Epargne::changeTaux(4.25)
Epargne::changeTaux(4.25) ;;
 Classes & Objets 28

 Crée par l'opérateur new, en cours d'exécution du programme.

Objet dynamique

class
class Vecteur
Vecteur
{{ /* /* …
… déclarations
déclarations de
de la
la classe
classe */ */ }} ;;
//// ...
... dans
dans le
le main()
main()
Vecteur
Vecteur ** ptrV1ptrV1 ;; //// ptrV1
ptrV1 contient
contient l'adresse
l'adresse d'un
d'un vecteur
vecteur dynamique
dynamique
ptrV1
ptrV1 == new new Vecteur
Vecteur ;; //// initialisation
initialisation :: appel
appel constructeur
constructeur
ptrV1
ptrV1 ->
-> afficheVect()
afficheVect() ;; //// accès
accès aux
aux membres
membres d'un
d'un objet
objet dynamique
dynamique

delete
delete ptrV1
ptrV1 ;; //// l'utilisateur
l'utilisateur doit
doit lui
lui même
même effacer
effacer ces
ces objets
objets
delete
delete []
[] ptrTableau
ptrTableau ;; //// delete
delete dans
dans le
le cas
cas d'un
d'un tableau
tableau d'objets
d'objets

//// delete
delete appelle
appelle automatiquement
automatiquement le
le destructeur
destructeur d’objets
d’objets
 Classes & Objets 29

 Constructeur de copie

Initialisation d'un objet dans l'une des situations :

- Déclaration d'un objet avec initialisation :
Vecteur a(10,20) ; Vecteur b = a ;
- Objet transmis par valeur comme paramètre d'appel fonction.
- Objet comme valeur de retour d'un appel de fonction.

Cette initialisation fait appel au Constructeur de copie

- Constructeur de copie par défaut (système).
- Constructeur de copie défini dans la classe (prog. dynamique).
 Classes & Objets 30

 Membres objets d'une classe

class
class Roue
Roue
{{ public
public ::
Roue(float
Roue(float d,d, int
int l)l) {{ diametre=d
diametre=d ;; largeur=l
largeur=l ;; }} ;;
private
private ::
float
float diametre
diametre ;; //// en en pouces
pouces
int
int largeur
largeur ;; //// en
en cm
cm }} ;;
class
class Voiture
Voiture
{{ public
public ::
Voiture(char
Voiture(char *m,
*m, float
float d,
d, int
int l)l) ;; //// définition
définition :: page
page suivante
suivante
private
private ::
char
char marque [10] ;;
marque[10]
Roue
Roue rAvantD,
rAvantD, rAvantG,
rAvantG, rArrD,
rArrD, rArrGrArrG ;; //// membres
membres objets
objets
}} ;;
 Classes & Objets 31

Définition du constructeur Voiture(…)

- Il faut prévoir les initialisateurs des membres objets, qui
déclencherons le constructeur d'objets Roue.
- En plus, des paramètres nécessaires pour l'objet Voiture.

Voiture::Voiture(char
Voiture::Voiture(char *m,
*m, floatfloat d,
d, int
int l)l)
:: rAvantD(d,
rAvantD(d, l)l) ,, rAvantG(d,
rAvantG(d, l)l) ,, rArrD(d,
rArrD(d, l)l) ,,
rArrG(d,
rArrG(d, l)l)
//// initialisateurs
initialisateurs de
de membres
membres
objets
objets
{{ strcpy(
strcpy( marque,
marque, m
m )) ;; }}
//// un
un exemple
exemple de
de déclaration
déclaration d'objet
d'objet pourrait
pourrait être
être ::
Voiture
Voiture maVoiture("Ford",
maVoiture("Ford", 13,
13, 185)
185) ;;
Garantie de non modification : const 32

 Objets constants
T const X(…) ; // X : objet constant de type T (NON modifiable)

X=expr ; // affectation non autorisée par le compilateur

 Paramètres de procédures qualifiés par const

void P1(T & XX) { … } // objet XX modifiable
void P2(T const & XX) { … } // objet XX constant

T const X(…) ; // un objet X constant

P1(X) ; // appel interdit
P2(X) ; // appel autorisé, P2 garantit la non modification de X

void P2(T const & XX) { … XX=expr ; … }

// le compilateur déclare une erreur de syntaxe
Garantie de non modification : const 33

 Procédures membres qualifiées par const

class T { int k ;
void P3() ;
void P4() const ;
};

avec la déclaration : T const X( ... ) ;

X.P3() ; // est un appel interdit

X.P4() ; // appel autorisé, car P4 garantit la non modification de X

void T::P4() const { ... k=expr ; ... } ;

// erreur de syntaxe, car P4 modifie l’instance courante
// exemple : X.P4() ;
Garantie de non modification : const 34

 Non modification à travers pointeurs ou références

T const * P = ... ; // par pointeur
T const & R = ... ; // par référence
/* Garantie de non modification de l’objet désigné par P ou par R.
Seul un pointeur sur const ou une référence à const est autorisé à
désigner un objet const. */

avec la déclaration : T const X ;

T * Q = &X ; T & S=X ; // sont des écritures interdites

/* Un accès offert par P ou R n’a pas le droit, par affectation,

initialisation ou passage de paramètre, de se transformer en un accès plus
riche permettant la modification : */

T const * P ; T * PP ; ...
PP = P ; T & RR(* P) ; // sont des écritures interdites.
 Héritage & Polymorphisme 35

Deux supports des principes d'extensibilité et de réutilisabilité

classe A classe de base

Héritage
classe B classe dérivée

La classe dérivée peut se différencier de sa classe de base par :

- l'ajout de membres données ;
- l'ajout de fonctions membres ;
- la redéfinition de fonctions membres héritées de la classe de base.
 Héritage & Polymorphisme 36

 Exemple : calcul des salaires d'une entreprise

Employe
Graphe d'héritage de
la hiérarchie d'employés Temporaire Cadre

Vendeur

Employe : caractéristiques communes à tous les employés,

Temporaire : classe dérivée pour les employés payés à l'heure,
Cadre : classe dérivée pour les employés avec salaire fixe,
Vendeur : acteurs externes payés à l'heure + commissions sur
les ventes.
 Héritage & Polymorphisme 37

 Classe de base Employe

class
class Employe
Employe
{{ public
public ::
Employe(
Employe( const
const char*
char* nm
nm )) ;; //// constructeur
constructeur d’objets
d’objets
void
void coutNom()
coutNom() ;; //// affiche
affiche le
le nom
nom
//// …
…
private
private ::
char
char nom[30]
nom[30] ;; }} ;;

Un employé temporaire, payé à l'heure, a les caractéristiques

communes à tout employé (nom) + tarif horaire + nombre d'heures.
Donc, on définit une classe Temporaire dérivée de classe Employe
 Héritage & Polymorphisme 38

 Classe Temporaire dérivée de la classe Employe

class
class Temporaire
Temporaire :: public
public Employe
Employe
{{ public
public ::
Temporaire(
Temporaire( constconst char*
char* nm nm )) ;; //// constructeur
constructeur d'objets
d'objets
void
void setTatif(
setTatif( float
float trf
trf )) ;;
void
void setHeures(
setHeures( float
float hres
hres )) ;;
private
private ::
float
float tarif
tarif ,, heures
heures ;; }} ;;

Un vendeur externe est temporaire, payé à l'heure, avec une

commission sur les ventes ( + commission + montant des ventes).
Donc, on définit une classe Vendeur dérivée de classe Temporaire
 Héritage & Polymorphisme 39

 Classe Vendeur dérivée de la classe Temporaire

class
class Vendeur
Vendeur :: public
public Temporaire
Temporaire
{{ public
public ::
Vendeur(
Vendeur( const
const char*
char* nm nm )) ;; //// constructeur
constructeur d'objets
d'objets
void
void setCommision(
setCommision( float
float comm
comm )) ;;
void
void setVentes(
setVentes( float
float ven
ven )) ;;
private
private ::
float
float commission,
commission, ventes
ventes ;; }} ;;

Un cadre a les caractéristiques communes à tout employé (nom) +

le salaire fixe.
Donc, on définit une classe Cadre dérivée de la classe Employe.
 Héritage & Polymorphisme 40

 Classe Cadre dérivée de la classe Employe

class
class Cadre
Cadre :: public
public Employe
Employe
{{ public
public ::
Cadre(
Cadre( const
const char*
char* nmnm )) ;; //// constructeur
constructeur d'objets
d'objets
void
void setSalaire(
setSalaire( float
float sal
sal )) ;;
private
private ::
float
float salaire
salaire ;; }} ;;

instance de la classe Employe Temporaire Vendeur Cadre

possède les membres nom nom nom nom
tarif tarif salaire
heures heures
En mémoire commission
ventes
 Héritage & Polymorphisme 41

 Accès aux membres

- Attention, les fonctions membres d'une classe dérivée n'ont
pas accès direct aux membres privés de la classe de base.

- Une instance d'une classe dérivée peut invoquer une méthode

publique de la classe de base.

//// exemple
exemple d'utilisation
d'utilisation
Vendeur
Vendeur vv11("Salim")
("Salim") ;;
vv11.setVentes(1000)
.setVentes(1000) ;; //// appel
appel Vendeur::setVentes()
Vendeur::setVentes()
vv11.setHeures(40.0)
.setHeures(40.0) ;; //// appel
appel Temporaire::setHeures()
Temporaire::setHeures()
//// …
…
vv11.coutNom(
.coutNom( )) ;; //// appel
appel Employe::coutNom()
Employe::coutNom()
 Héritage & Polymorphisme 42

 Constructeurs de classes dérivées

Le constructeur d'une classe dérivée appelle d'abord celui
de sa classe de base.

//// constructeur
constructeur de
de la
la classe
classe de base Temporaire
de base Temporaire
Temporaire::Temporaire(
Temporaire::Temporaire( const const char
char ** nm
nm ))
:: Employe(
Employe( nmnm )) ////
initialisateur
initialisateur
{{ tarif
tarif == 0.0
0.0 ;; heures
heures == 0.0
0.0 }} ;;

//// constructeur
constructeur de
de la
la classe dérivée Vendeur
classe dérivée Vendeur
Vendeur::Vendeur(
Vendeur::Vendeur( const
const char*
char* nm
nm )) :: Temporaire(
Temporaire( nm
nm ))
{{ commission
commission == 0.0
0.0 ;; ventes
ventes == 0.0
0.0 }} ;;
 Héritage & Polymorphisme 43

 Membres protégés

class
class Exemple
Exemple
{{ public
public :: //// membres
membres publics
publics
int
int nombre
nombre ;;
protected
protected :: //// membres
membres protégés
protégés
int
int secret
secret ;;
private
private :: //// membres
membres privés
privés
int
int topSecret
topSecret }} ;;

Un membre protégé est accessible aux fonctions membres

(et amies) de la classe où il est déclaré, ainsi qu'aux fonctions
membres (et amies) des classes dérivées.
 Héritage & Polymorphisme 44

 Types de dérivation
Publique : les membres publics de la classe de base sont
considérés comme membres publics dans la classe dérivée
class Cadre : public Employe { // … }

Privée : les membres publics et protégés de la classe de base

sont considérés comme membres privés dans la classe dérivée
class Cadre : private Employe { // … }

Protégée : les membres publics et protégés de la classe de

base deviennent des membres protégés dans la classe dérivée
class Cadre : protected Employe { // … }
 Héritage & Polymorphisme 45

 Liaisons statiques et dynamiques

Le polymorphisme recouvre deux aspects :
Possibilité de surcharger des fonctions ou de redéfinir des
méthodes à l'intérieur des classes dérivées.
Un appel à une fonction est converti lors de la compilation en
un branchement fixe, là ou se trouve le code (liaison statique).

Dans l'héritage, la version de la fonction à exécuter n'est

connue que lors de l'exécution du programme (liaison
dynamique).
Cette technique très puissante est réalisée dans les classes C++
à l'aide des fonctions virtuelles.
 Héritage & Polymorphisme 46

 Fonctions virtuelles
class
class Employe
Employe
{{ public
public ::
virtual
virtual float
float calculSalaire()
calculSalaire() const
const {{ return
return 00 ;; }} ;; //// fonction
fonction
//// …
… }} ;; //// virtuelle,
virtuelle, ne
ne sera
sera jamais
jamais
appelée.
appelée.
class
class Temporaire
Temporaire :: public
public Employe
Employe
{{ public
public ::
float
float calculSalaire()
calculSalaire() ;; //// fonction
fonction implicitement
implicitement virtuelle
virtuelle
//// …
… }} ;;
//…
//… exemple
exemple d'utilisation
d'utilisation
Temporaire
Temporaire emp1Temp(
emp1Temp( "Salim"
"Salim" )) ;; //// objet
objet emp1Temp,
emp1Temp,
Temporaire
Temporaire ** ptrTemp1
ptrTemp1 == && emp1Temp
emp1Temp ;; //// avec avec pointeur
pointeur
cout
cout <<
<< ptrTemp1->
ptrTemp1-> claculSalaire()
claculSalaire() ;; //// Temporaire::calculSalaire()
Temporaire::calculSalaire()
 Héritage & Polymorphisme 47

 Héritage multiple

class
class C C :: public
public A,
A, public
public B
B classe de base A classe de base B
{{
//// …
…
}} ;; classe dérivée C

La classe dérivée (C) hérite des membres de toutes ses

classes de base (A, B).

Le constructeur de la classe dérivée (C) doit être suivi de la

liste des initialisateurs de ses classes de base (A , B).
 Héritage & Polymorphisme 48

 Classe virtuelle

Employe

Temporaire Cadre

Vendeur
héritage multiple
ChefVentes

La classe virtuelle fournit un moyen de partager l'information.

Elle permet d'économiser de l'espace mémoire.
Virtual : garantie une seule copie de Employe dans ChefVentes.
 Héritage & Polymorphisme 49

Hiérarchie des employés avec une classe virtuelle

class
class Employe
Employe
{{ //// …
… }} ;;
class
class Temporaire
Temporaire :: public
public virtual
virtual Employe
Employe
{{ //// …
… }} ;; //// virtual
virtual :: une
une copie
copie d’Employe
d’Employe dans
dans
Chefventes
Chefventes

class
class Vendeur
Vendeur :: public
public Temporaire
Temporaire
{{ //// …
… }} ;;
class
class Cadre
Cadre :: public
public virtual
virtual Employe
Employe
{{ //// …
… }} ;; //// virtual
virtual :: une
une copie
copie d’Employe
d’Employe dans
dans Chefventes
Chefventes

class
class ChefVentes
ChefVentes :: public
public Vendeur
Vendeur ,, public
public Cadre
Cadre
{{ //// …
… }} ;;
 Classe générique 50

 Définition et exemple
Classe générique : sert de patron (template), c'est à dire modèle
pour d'autres classes, et dans laquelle ce modèle peut être
paramétré par d'autres classes, objets, et/ou opérations .

Exemple d'une pile : si l'on doit construire une classe Stack qui
gère une pile sous forme de tableau dynamique, cette gestion est
identique quel que soit le type de ses éléments :

- une pile d'entiers

- une pile de caractères
mêmes besoins
- une pile d'objets &
- une pile de pointeurs même fonctionnement
 Classe générique 51

 La classe générique Stack

empiler dépiler (pop)

(puch)
sommet
(top)

Pour la gestion de Stack, il faut :

- réserver en mémoire dynamique une zone d’1 certaine taille ;
- avoir l'adresse de cette zone ;
- avoir un pointeur sur l'élément au sommet de Stack (top) ;
- pouvoir empiler/dépiler un élément au sommet de Stack ;
- pouvoir tester si Stack est pleine ou vide.
 Classe générique 52

 Définition de la classe Stack (1/3)

template
template <class
<class T> T> class
class Stack Stack //// pile
pile d'éléments
d'éléments dede type
type TT
{{ public
public ::
Stack(
Stack( int
int ss )) ;; //// constructeur
constructeur
~Stack(
~Stack( )) {{ delete[]
delete[] adr adr ;; }} ;; //// destructeur
destructeur
void
void push(
push( TT elemelem )) ;; //// prototype
prototype fonction
fonction empiler
empiler
TT pop(
pop( void
void )) ;; //// prototype
prototype fonction
fonction dépiler
dépiler
int
int empty(
empty( void
void )) const const {{ returnreturn (( top top ==== NULL
NULL )) ;; }}
int
int full(
full( void
void )) ;; //// pile
pile pleine
pleine ??
int
int howmany(
howmany( void void )) ;; //// nombre nombre d'éléments
d'éléments dans
dans la
la pile
pile
private
private ::
TT ** top
top ;; //// pointeur
pointeur sur sur sommet
sommet
TT ** adr
adr ;; //// adresse
adresse zonezone dynamique
dynamique
int
int size
size ;; }} //// taille
taille en
en nombre
nombre d'éléments
d'éléments dede type
type TT
 Classe générique 53

 Définition de la classe Stack (2/3)

template
template <class
<class T>
T> Stack<T>::Stack(
Stack<T>::Stack( int
int ss )) //// constructeur
constructeur
{{ adr
adr == new
new T[s]
T[s] ;; top
top == NULL
NULL ;; size
size == ss ;; }}
template
template <class
<class T>
T> void
void Stack<T>::puch(
Stack<T>::puch( TT elem
elem )) //// empiler
empiler
{{ ifif (( top
top ==== NULL
NULL )) top
top == adr
adr ;; else
else top++
top++ ;;
** top
top == elem
elem ;; }}
template
template <class
<class T> T> TT Stack<T>::pop(void)
Stack<T>::pop(void) //// dépiler
dépiler
{{ TT elem
elem ;;
elem
elem == ** toptop ;;
ifif (( top
top ==== NULL
NULL )) toptop == NULL;
NULL; else
else top--
top-- ;;
return
return elem elem ;; }}
 Classe générique 54

 Définition de la classe Stack (3/3)

template
template <class
<class T>
T> int
int Stack<T>::full(void)
Stack<T>::full(void) //// pile
pile pleine
pleine ??
{{ ifif (( top
top !=
!= NULL
NULL )) return
return (( size
size ==== top
top –– adr
adr +1
+1 )) ;;
else
else return
return 00 ;; }}
template
template <class
<class T>
T> int
int Stack<T>::howmany(void)
Stack<T>::howmany(void) //// taille
taille
{{ ifif (( top
top ==
== NULL
NULL )) return
return 00 ;; else
else return
return (top
(top –– adr
adr +1)
+1) ;; }}

 Utilisation de la classe générique Stack

Stack
Stack <int>
<int> pileInt(20)
pileInt(20) ;; //// déclaration
déclaration d'une
d'une pile
pile pour
pour 20
20 entiers
entiers
Stack
Stack <char>
<char> pileCar(50)
pileCar(50) ;; //// une
une pile
pile pour
pour 50
50 caractères
caractères
 Classe générique 55

 Exemple d'utilisation de la classe Stack

#include
#include "Stack.h"
"Stack.h"
void
void main()
main()
{{ Stack
Stack <int>
<int> pileI(10)
pileI(10) ;; //// pile
pile pour
pour 10
10 nombres
nombres entiers
entiers
int
int ii == 11 ;;
while
while (( !! pileI.full()
pileI.full() ))
{{ pileI.push(i++)
pileI.push(i++) ;;
cout
cout <<
<< "\n
"\n IlIl yy aa "" <<
<< pileI.howmany()
pileI.howmany() ;;
cout
cout <<
<< "" éléments
éléments dansdans la
la pile"
pile" ;; }}

while
while (( !pileI.empty()
!pileI.empty() ))
cout
cout <<
<< "\n"
"\n" <<
<< pileI.pop()
pileI.pop() ;;
}}
 Classe générique 56

 Une Stack d'objets de type Vecteur (1/2)

class
class Vecteur
Vecteur //// àà 33 composantes
composantes pour
pour utilisation
utilisation ultérieure
ultérieure
{{ public
public ::
Vecteur(
Vecteur( float
float c1=0,
c1=0, floatfloat c2=0,
c2=0, float
float c3=0
c3=0 )) ;;
friend
friend affiVect
affiVect & & operator<<(
operator<<( affiVect
affiVect && affi,
affi, Vecteur
Vecteur && vv );
);
private
private :: float
float vect[3]
vect[3] ;; }} ;;
Vecteur::Vecteur(
Vecteur::Vecteur( floatfloat c1,
c1, float
float c2,
c2, float
float c3
c3 ))
{{ vect[0]=c1
vect[0]=c1 ;; vect[1]=c2
vect[1]=c2 ;; vect[2]=c3
vect[2]=c3 ;; }}
//// surcharge
surcharge pour
pour affichage
affichage du
du vecteur
vecteur
affiVect
affiVect &
& operator<<
operator<< (( affiVect
affiVect && affi,
affi, Vecteur
Vecteur && vv ))
{{ affi
affi << "\n" <<v.vect
<<"\n" [0] <<",
<<v.vect[0] <<", "" <<v.vect [1] <<",
<<v.vect[1] <<", "" <<v.vect [2] ;;
<<v.vect[2]
return
return affi
affi ;; }}
 Classe générique 57

 Une Stack d'objets de type Vecteur (2/2)

//// exemple
exemple d'utilisation
d'utilisation
#include
#include "Stack.h"
"Stack.h" //// fichier
fichier déclaration
déclaration classe
classe générique
générique
void
void main()
main()
{{ Stack
Stack <Vecteur>
<Vecteur> pileV(5)
pileV(5) ;; //// pile pile pour
pour 55 vecteurs
vecteurs
int
int ii =10
=10 ;;
Vecteur
Vecteur v( v( i,i, i++,
i++, i+2
i+2 )) ;;
while
while (( !! pileV.full()
pileV.full() )) //// on
on empile
empile 55 fois
fois le
le même
même vecteur
vecteur
{{ pileV.push()
pileV.push() ;;
cout
cout << << "\n
"\n IlIl yy aa "" <<<< pileV.howmany()
pileV.howmany() ;;
cout
cout << << "éléments
"éléments dans dans la
la pile"
pile" ;; }}
while
while (( !pileV.empty()
!pileV.empty() ))
{{ cout
cout << << "\n"
"\n" << << pileV.pop()
pileV.pop() ;; }}
 C++ : Classe container 58

 Définition et exemples

Classe container : définit un type d'objet conçu pour contenir

des collections d'autres objets. La collection d'objets d'une
classe container peut être homogène ou hétérogène.
Comme exemples : listes, piles, queues, ou ensembles.

La classe générique Stack est typiquement une classe

container, puisqu'elle gère une pile d'objets.
• Cela ne signifie pas qu'une classe générique soit une classe
container systématiquement.
• Comme exemple de classe purement générique, citons une
classe Addition qui réaliserait l'addition de deux objets.
 C++ : Classe conteneur 59

 Classe Addition purement générique

template
template <class
<class T>T> class
class Addition
Addition
{{
public
public ::
//// …
…
TT add(
add( TT obj1,
obj1, TT obj2
obj2 )) {{ return
return (obj1
(obj1++obj2)
obj2) ;; }}
}} ;;
//// …
… exemple
exemple d'utilisation
d'utilisation
void
void main()
main()
{{ Addition<int>
Addition<int> intAdd
intAdd ;;
cout
cout <<
<< intAdd.add(5,
intAdd.add(5, 10)
10) ;;
}}