Programmation Orientée Objets

Chapitre 4
Héritage

Pr. Saïd OUATIK EL ALAOUI

s_ouatik@yahoo.com
ouatikelalaoui.said@uit.ac.ma
 Plan
 Notion d’Héritage
 Héritage simple
 Droits d’accès aux membres de la classe

 Redéfinition de fonctions membres

 Constructeurs, destructeurs

 Amitié

 Fonctions virtuelles
 Classes abstraites

2014-2015 2
 Notion d’Héritage
 Permet de définir une nouvelle classe (classe dérivée) à partir
d’une ou plusieurs classes existantes (classes de base).

 La classe dérivée héritera les membres de la classe de base, tout

en ajoutant de nouveaux attributs et de nouvelles méthodes

 Représente la relation EST UN(E)

 Un cercle est une forme géométrique
 Une voiture est un véhicule
 Une employé est une personne

2014-2015 3
 Notion d’Héritage
 L’héritage peut être:
 Simple : Une seule classe de base
 Multiple: Plusieurs classes de base

 Le concept d’héritage permet de:

 Exprimer les relations structurelles et
sémantiques entre les classes
 Réduire les redondances de description et de
stockage des propriétés
 Réutiliser les classes existantes
2014-2015 4
 Notion d’Héritage
Exemple

véhicule

avion voiture moto

de course fourgonnette

2014-2015 5
 Notion d’Héritage
 La classe dérivée est un cas particulier de la classe de base
 Si une classe B dérive de la classe A, alors
 B va hériter implicitement l’ensemble:
 Des attributs de A
 Des méthodes de A

 B peut définir des attributs et des méthodes supplémentaires

(enrichissement)

 B Peut redéfinir certaines méthodes

2014-2015 6
 Syntaxe
Héritage simple
class class_derivee:public class_de_base
{ /* définitions des méthodes et des attributs
spécifiques à la classe dérivée*/ … };

 Exemple
class personne {
char nom[20];
char prenom[20];
int CIN;
public:
void saisir(char*,char*,int);
void afficher();
};
class etudiant : public personne {
int CNE;
public:
void saisir_cne(int);
2014-2015 void afficher_cne(); 7
};
 Héritage simple
Mode de dérivation
 Dérivation public: C’est le mode le plus utilisé
 Syntaxe

class class_derivee : public class_de_base

{ ----
--------
public:
-------
-------- …
};

Dans une dérivation publique, tous les membres

public de la classe de base restent public dans
la classe dérivée
2014-2015 8
 Héritage simple
Mode de dérivation
 Remarques:
 Les fonctions membres de la classe dérivée n’ont pas
accès aux membres privés de la classe de base.

 Dans une dérivation privée, l’utilisateur d’une classe

dérivée n’a pas accès aux membres publique de la
classe de base.

class B : private A
{ ----
--------
public:
-------
-------- …
};
2014-2015 9
 Héritage simple
Droit d’accès aux membres d’une classe

 Trois modes d’accès aux membres d’une classe:

 Public : Accès permis à toute fonction à partir de

n’importe quel point du programme

 private (mode par défaut) : Accès permis aux

fonctions membres de la classe

 protected (lié à l’héritage): Accès permis aux

fonctions membres de la classe et aux fonctions
membres des classes dérivées .

2012-2013 10
 Héritage simple
Droit d’accès aux membres de classe
 Exemple
class A { void B::fct(int x)
public: {
int pub; pub = x // ok accès possible
pro = x; // ok accès possible
protected : priv = x; //erreur
int pro; //accès non autorisé
}
private :
int priv; void fexterne(A pa, int x)
}; {
pa.pro= x; // erreur
class B : public A { pa.priv= x; // erreur
public: pa.pub = x; // ok
void fct(int x); }
};

2014-2015 11
 Héritage simple
Redéfinition de fonctions
 Besoin d’adapter certaines fonctions de la classe de base à la
classe dérivée

 La nouvelle fonction doit garder le même nom que celui de la

classe de base

 Redéfinition  surdéfinition

 La nouvelle définition (celle de la classe dérivée) va masquer

l’ancienne (celle de la classe de base). Mais elle ne la remplace
pas.
2014-2015 12
 Héritage simple
Redéfinition de fonctions
 Exemple
class Rectangle { float
protected: Rectangle3D::surface()
float largeur; {
float hauteur; return
public: (2*largeur*hauteur+
float surface(); 2*largeur*profondeur +
2*hauteur*profondeur);
}; }
float Rectangle::surface()
{ return largeur*hauteur; void main()
} {
class Rectangle3D:public Rectangle Rectangle3D r;
{
protected: r.surface();//celle de
la classe Rectangle3D
float profondeur; }
public:
float surface();
};
2014-2015 13
 Héritage simple
Constructeur de la classe de base

 Trois cas possibles pour la classe de base

 Constructeur n’est pas défini

 Aucun problème ne se pose

 Constructeur sans paramètres

 Il sera appelé automatiquement à la création d’un objet de
la classe dérivée.

 Constructeur avec paramètres

 Dans la définition du constructeur de la classe dérivée, on
doit spécifier les paramètres à transmettre au constructeur
de la classe de base.
2014-2015 14
 Héritage simple
Constructeur de la classe de base
Exemple 1: Constructeur de la
classe de base sans paramètres
Class Point Class Point_colore: public Point
{ int x, y; {int couleur;
Public: Public:
Point(); Point_colore(int);
Void afficher(); Void affiche();
}; };
Point:: Point() Point_colore::Point_colore(int cl)
{x=0; {couleur=cl;
Y=0; }
} Void Point_colore:: affiche()
Void Point :: affiche() {
{ Point::affiche(); // appel méthode de
Cout<<"Cordonnees: "<<x<<y; //la classe de base
}; Cout<<« \nCouleur »<<couleur;
}
2014-2015 15
 Héritage simple
Constructeur de la classe de base avec paramètres
 Dans ce cas, on doit définir un constructeur dans la classe dérivée.

 Comment passer les paramètres au constructeur de la classe de base?

 Explicitement: lors de la définition du constructeur de la classe dérivée

 Syntaxe
class_derivee::class_derivee(param1,param2,…):base(parami,…)
{------
------
--------
}
 Exemple

2014-2015 16
 Héritage simple
Constructeur de la classe de base
Exemple 2: Constructeur de la
classe de base avec paramètres
class Point class Point_colore: public Point
{ {int couleur;
protected: public:
int x, y; Point_colore(int, int, int);
Public: void affiche();
Point(int, int); };
void afficher(); Point_colore::Point_colore(int abs,
}; int ord, int cl): Point(abs, ord)
Point:: Point(int abs,int ord) {couleur=cl;
{x=abs; }
Y=ord; void Point_colore:: affiche()
} {
void Point :: affiche() cout<<x<<" " <<y;
{ cout<<"\nCouleur"<<couleur;
cout<<"Cordonnees: "<<x<<y; }
}; 2014-2015 17
 Héritage simple
Constructeur de recopie

 Recopie des attributs de la classe de base A et

ceux de la classe dérivée B

 Deux cas :
 La classe dérivée n’a pas de constructeur de
recopie

 La classe dérivée possède un constructeur de

recopie
2014-2015 18
 Héritage simple
Constructeur de recopie
 Classe dérivée n’a pas de constructeur de
recopie
 Appel des constructeurs de recopie dans l’ordre
suivant:
 Constructeur de recopie explicite ou par défaut de la classe
de base

 Constructeur de recopie par défaut de la classe dérivée

2014-2015 19
 Héritage simple
Constructeur de recopie
 Classe dérivée B possède un constructeur de
recopie

 Il sera appelé
 Pas d’appel automatique du constructeur de
recopie de la classe de base.
 Le constructeur de recopie de A doit être
mentionné dans l’entête du constructeur de recopie
de B.
 Sinon il y aura appel au constructeur sans
arguments de A (obligatoire).

2014-2015 20
 Héritage simple
Constructeur de recopie
Constructeur de recopie défini à la fois
dans la classe de base et la classe dérivée
class Point class Point_colore: public Point
{ protected: {int couleur;
int x, y; Public:
Public: Point_colore(int, int, int);
Point(int, int); Point_colore(Point_colore &);
Point(Point &); //constr de recopie void affiche();
Void afficher(); };
}; Point_colore::Point_colore(int abs,
Point:: Point(int abs, int ord) int ord, int cl): Point(abs, ord)
{x=abs; {couleur=cl;
y=ord; }
} void Point_colore:: affiche()
void Point :: affiche() {
{ Cout<<x<<<" "<<y;
Cout<<"Coordonnees: "<<x<<y; Cout<<"\nCouleur "<<couleur;
}; 2014-2015 } 21
 Héritage simple
Constructeur de recopie
Constructeur de recopie défini à la fois
dans la classe de base et la classe dérivée

Point_colore::Point_colore(Point_colore & p): Point(p)

{
couleur=p.couleur;
}

2014-2015 22
 Héritage simple
Constructeur/destructeur

 Ordre d’appel
 Lors de la déclaration d’un objet de la classe dérivée, le
constructeur de la classe de base est appelé avant celui
de la classe dérivée

 De façon symétrique le destructeur de la classe de base

est appelée après le destructeur de la classe dérivée

2014-2015 23
 Héritage simple
Amitié
 La déclaration d’amitié pour une classe
accorde aux fonctions de cette classe les
mêmes droits d’accès que ceux des fonctions
membres

 La déclaration d’amitié pour une classe ne se

propage pas aux classes dérivées

 L’amitié pour une fonction n’est pas héritée. A

chaque dérivation il faut définir l’amitié pour
cette fonction
2014-2015 24
 Fonctions virtuelles
notion de typage
 La notion de typage concerne les objets dynamiques
et l’héritage
 Soient les instructions suivantes: A
A *pp; Afficher()
B b;
pp= &b;
 pp : pointeur de type A B
 pp : pointe sur un objet de type B
Afficher()

 L’instruction pp->Afficher(); correspond à quelle fct

afficher() de A ou de B?

 Question: comment choisir la fonction à exécuter?

2014-2015 25
 Fonctions virtuelles
notion de typage

 Typage statique:
 Le type de l’objet pointé est déterminé au moment
de la compilation

 Le choix de la fonction est déterminé par le type

du pointeur et non par celui de l’objet pointé

 L’instruction pp->Afficher(); correspond donc à

celle de la classe A

2014-2015 26
 Fonctions virtuelles
notion de typage
 Typage dynamique:
 Le type de l’objet pointé est déterminé lors de l’exécution
et non lors de la compilation

 Le choix des fonctions est donc fait lors de l’exécution

 Le choix de la fonction est déterminé par le type de l’objet

pointé
 L’instruction pp->Afficher(); correspondra à celle de la
classe B

 Obtenu par les fonctions virtuelles

2014-2015 27
 Fonctions virtuelles
 Faire précéder la fonction en question par le mot clé virtual
 Class A  Class B: public A
 {protected:  {……
 ……  public:
 public:  void fct();
 Virtual void fct();  ….
 ….  };
 };

 Le mot virtual est utilisé une seule fois. Il ne doit pas se répéter pour
une même méthode au niveau des classes dérivées.
 Un constructeur ne peut pas être virtual, alors que le destructeur peut
l’être.
2014-2015 28
 Fonctions virtuelles pures
 Fonction déclarée
 Comme méthode abstraite
 Sans définition dans une classe (pas de code)
 Déclarée avec initialisation à zéro
 Devant être redéfinie dans les classes dérivées

 Syntaxe
virtual type_retour nom_fonc(param)=0;

2014-2015 29
 Classes abstraites
 Une classe est dite abstraite s’il n’est pas possible de créer des
objets de son type (non instanciable)

 Toute classe comportant une fonction virtuelle pure est

abstraite

 Possibilité de définir des pointeurs et des références sur une

classe abstraite

 Classe destinée uniquement à la dérivation

 Exemple Class A
{protected:
……
public:
Virtual void affiche()=0;
….
2014-2015 }; 30