‫المدرسة الوطنية للمهندسين بتونس‬

École Nationale d’Ingénieurs de Tunis

Chap-4 : Héritage

Kamel Hamrouni
Abir Gallas
Introduction
 L’héritage appelé aussi dérivation est un principe de la POO
permettant de créer une nouvelle classe à partir d’une classe
existante tout en profitant des attributs et des méthodes de
cette dernière et en définissant de nouveaux attributs et de
nouvelles méthodes propres à la classe dérivée. Par cette
méthode on crée une hiérarchie de classes de plus en plus
spécialisées. Cela a un avantage majeur de ne pas partir
toujours de zéro dans la conception d’applications.
 La hiérarchie des classes constituée est aussi appelée
arborescence des classes. Au niveau de chaque nœud de
l’arborescence existe une relation de parenté. Le nœud est
appelé classe de base, ou classe parent, ou classe ancêtre, ou
classe père ou classe mère… et les classes dérivées sont
appelés classes filles ou sous-classes.

2
Introduction (2)
Exemple

3
Introduction (3)

Cette notion pose bien entendu un certain nombre de questions

auxquelles il va falloir répondre :

 Comment protéger les données ?

 Comment appeler les constructeurs et les destructeurs des
différentes classes ?
 Comment faire avec les classes amies ?
 Peut-on hériter de plusieurs classes mères ?
 Etc…

4
Héritage Simple
Mode de
dérivation
Classe
mère

Classe
dérivée La classe B hérite de façon publique de
la classe A. Tous les membres publics ou
protégés de la classe A font partie de
l’interface de la classe B.
5
Mode de Dérivation

Le mode de dérivation, spécifié par un des mots public, protected ou bien

private, permet d’indiquer la protection des données de la classe de base
dans la dérivation :

 La classe dérivée pourra-t-elle accéder à tous les membres (private,

protected et public) de la classe de base ?
 Comment devra-t-on considérer, dans la classe dérivée, les membres de la
classe de base ?

6
Mode de Dérivation (2)
Le mode de dérivation constitue donc une sorte de filtre dans le processus
de dérivation :
 Les données seront ou non accessibles par la classe fille et les classes
petites filles.
 Les membres privés ne sont jamais accessibles par les membres de la
classe dérivée.
 Le mode de dérivation ne concerne donc que les membres protected ou
public.
 En mode de dérivation public, le statut d’un membre reste inchangé : un
membre public reste public et un membre protected reste protected.
 En mode de dérivation protected, le statut d’un membre devient protected.
 En mode de dérivation private, le statut d’un membre devient private.
C’est à dire qu’il sera considéré dans la classe dérivée comme un membre
private donc inaccessible par les classes petites filles.

7
Mode de Dérivation (3)
 Si le mode de dérivation n’est pas spécifié, le compilateur prend par
défaut le mode private pour une classe et public pour une structure.
 Le tableau suivant résume le statut des membres selon le mode de
dérivation :

8
Héritage « public »
C’est le mode d’héritage le plus courant. Il donne aux membres public et
protected, le même statut dans la classe dérivée.
Exemple

9
Héritage « protected »
Le mode protected donne aux membres public et protected, le statut protected
dans la classe dérivée.
Exemple

10
Héritage « private »
Le mode private donne aux membres public et protected, le statut private
dans la classe dérivée.
Exemple

11
Redéfinition de méthodes dans la classe
dérivée

On peut redéfinir une fonction dans une classe dérivée si

on lui donne le même nom que dans la classe de base. Il y
aura ainsi deux fonctions de même nom dans un objet, mais
il sera possible de les différencier en utilisant l’opérateur de
résolution de portée ::
Si A est la classe de base, B la classe dérivée et « fonc » le
nom de la fonction redéfinie :

 fonc ( ) : fera appel à la fonction redéfinie alors que

 A ::fonc ( ) : fera appel à la fonction de la classe de base.

12
Héritage de constructeurs\destructeurs

Les constructeurs, constructeur de copie, destructeurs et

opérateurs d’affectation ne sont jamais hérités.
 Les constructeurs par défaut des classes de bases sont
automatiquement appelés avant le constructeur de la classe
dérivée.
 Pour ne pas appeler les constructeurs par défaut, mais des
constructeurs avec des paramètres, on doit employer une
liste d’initialisation. L’appel des destructeurs se fera dans
l’ordre inverse des constructeurs.

13
Héritage de constructeurs\destructeurs (2)
Exemple 1

Ce programme affiche:

Const. de la classe A
Const. de la classe B
Dest. de la classe B
Dest. de la classe A

14
Héritage de constructeurs\destructeurs (3)
Exemple 2 : Appel du constructeur avec paramètres

15
Héritage et amitié

L’amitié ne se propage pas aux membres de la classe

dérivée et ne s’étend pas aux générations suivantes.

16
Conversion de type dans une hiérarchie
de classes

 Conversion de variable

Il est possible de convertir implicitement une instance d’une

classe dérivée en une instance de la classe de base si
l’héritage est public. L’inverse est interdit car le compilateur
ne saurait pas comment initialiser les membres de la classe
dérivée.

17
Opérateurs de conversion (3)
Exemple
void traitement1(Vehicule v)
class Vehicule { // ...
{ public: v.f1(); // OK
void f1(); // …
}
// ...
void main()
}; {
class Voiture : public Vehicule Voiture R25;
{ public: traitement1( R25 );
int f1(); // R25 est automatiquement
//converti en une instance de la
} //classe Vehicule
}

18
Conversion de type dans une hiérarchie
de classes (2)

 Conversion de pointeur

Un pointeur (ou une référence) sur un objet d’une classe

dérivée peut être implicitement converti en un pointeur
(ou une référence) sur un objet de la classe de base. Cette
conversion n’est possible que si l’héritage est public, car la
classe de base doit posséder des membres public
accessibles (ce n’est pas le cas d’un héritage protected ou
private).

19
Conversion de type dans une hiérarchie
de classes (3)
Exemple
C’est le type du pointeur qui détermine laquelle des méthodes f1( )
est appelée

void traitement1(Vehicule *v)

{
// ...
v->f1( ); // OK
// ...
}
void main()
{ Voiture R25;
traitement1( &R25 );
}

20
Héritage multiple

En langage C++, il est possible d’utiliser l’héritage multiple :

Une classe peut hériter de deux ou plusieurs classes. Pour
chaque classe de base, on peut définir le mode d’héritage.

21
Héritage multiple (2)
Exemple
class A class C: public B, public A
{ public: { int c;
void fa() { /* ... */ } public:
protected: void fc();
int a; };
};
class B void C::fc()
{ public: { int i;
void fb() { /* ... */ } fa( );
protected: i = a + b;
int b; }
};

22
Héritage multiple (3)

Ordre d’appel des constructeurs

Dans l’héritage multiple, les constructeurs sont appelés

dans l’ordre de déclaration de l’héritage. Dans l’exemple
suivant, le constructeur de la classe C appelle le
constructeur de la classe B, puis celui de la classe A et en
dernier lieu le constructeur de la classe dérivée, même si
une liste d’initialisation existe

23
 Héritage multiple (4)
Exemple class C: public B, public A
class A // ordre d’appel des constructeurs
{ public: { public:
C(int i, int j) : A(i) , B(j)
A(int n=0) { /* ... */ }
{ /* ... */ }
// ... // liste d’initialisation
}; // ...
class B };
void main()
{ public:
{ C objet_c;
B(int n=0) { /* ... */ } // appel des constructeurs
// ... //B(), A() et C()
}; // ...
}
Les destructeurs sont appelés dans l’ordre inverse de celui des constructeurs.
24