Université Sultan Moulay Slimane

Faculté Polydisciplinaire Khouribga

Mathématiques, Informatique et Physique (MIP)

Programmation Orientée Objet (C++)

Chapitre 3 : Héritage et Polymorphisme

Pr. Ibtissam Bakkouri

[Link]@[Link]

Année Universitaire : 2024/2025

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Plan

1 Introduction

2 Héritage

3 Polymorphisme

4 Classes Abstraites

5 Interfaces et Héritage multiple

6 Conclusion

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 2/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Introduction

Ce chapitre explore deux concepts clés de la programmation

orientée objet : l’héritage et le polymorphisme. Ces mécanismes
permettent de structurer et de réutiliser le code de manière
efficace.
L’héritage : Permet à une classe de dériver d’une autre,
héritant ainsi de ses attributs et de ses méthodes.
Le polymorphisme : Permet de traiter des objets de types
différents de manière uniforme en utilisant des fonctions
virtuelles.
L’héritage et le polymorphisme permettent de créer des
architectures logicielles modulaires et extensibles.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 3/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Introduction
Ce chapitre aborde les concepts fondamentaux du C++
permettant de gérer l’héritage et le polymorphisme de manière
flexible et puissante.
Principe de l’héritage : Comprendre comment une classe
dérivée hérite des propriétés d’une classe de base.
Les aspects syntaxiques : Apprendre à définir des classes
dérivées, à gérer les constructeurs et les destructeurs.
Contrôle d’accès : Savoir comment protéger les membres
d’une classe pour contrôler leur accessibilité.
Polymorphisme avec fonctions virtuelles : Implémenter des
fonctions virtuelles pour permettre un comportement
dynamique.
Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 4/60
 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Introduction

Réutilisation du code avec classes abstraites : Créer des

classes abstraites pour une réutilisation efficace du code.
Interfaces et héritage multiple : Utiliser des interfaces pour
des contrats de méthode et comprendre l’héritage multiple en
C++.
L’objectif de ce chapitre est de maîtriser ces techniques pour écrire
un code C++ flexible et réutilisable.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 5/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Héritage

L’héritage est un mécanisme fondamental en programmation

orientée objet qui permet à une classe dérivée d’hériter des
attributs et méthodes d’une classe de base.
Cela permet de réutiliser et d’étendre le code d’une manière
structurée et flexible.
Principes clés :
Une classe dérivée hérite des membres publics et protégés de
la classe de base.
La classe dérivée peut ajouter de nouveaux membres ou
redéfinir des méthodes existantes.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 6/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Syntaxe de l’Héritage

La syntaxe de base pour l’héritage en C++ est la suivante :

Syntaxe : class NomDeClasseDerivee :
typeDeRelation NomDeClasseBase
Une classe Animal est la classe de base.
Une classe Chien hérite de Animal.
Exemple d’héritage :
Classe de base : Animal
Classe dérivée : Chien

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 7/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Syntaxe de l’Héritage

Code de base :
class Animal {
public:
void parler() { cout « "Je suis un animal" « endl;
}
};
class Chien : public Animal {
public:
void parler() { cout « "Je suis un chien" « endl;
}
};
Ici, Chien hérite de Animal.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 8/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Utilisation de l’Héritage
L’héritage permet de réutiliser des comportements de la classe de
base tout en personnalisant le comportement des classes dérivées.
Exemple d’utilisation :
Créez un objet de la classe de base : Animal a;
Créez un objet de la classe dérivée : Chien c;
Appel de la méthode parler() sur chaque objet.
Code d’exécution :
int main() {
Animal a;
Chien c;
[Link](); // Affiche : Je suis un animal
[Link](); // Affiche : Je suis un chien
}
Ici, Chien a redéfini la méthode parler().
Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 9/60
 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Redéfinition de Méthodes

En héritage, une méthode d’une classe de base peut être redéfinie

dans la classe dérivée. Cela permet de personnaliser ou étendre le
comportement d’une méthode.

Exemple de redéfinition :
Classe de base : Animal
Méthode : parler()
Classe dérivée : Chien redéfinit parler()

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 10/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Redéfinition de Méthodes

Exemple de code :
class Animal {
public:
virtual void parler() { cout « "Je suis un
animal" « endl; }
};
class Chien : public Animal {
public:
void parler() { cout « "Je suis un chien" « endl;
}
};
La méthode parler() est redéfinie dans Chien.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 11/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Constructeur et Héritage

Le constructeur d’une classe dérivée peut appeler le constructeur

de la classe de base à l’aide d’une liste d’initialisation.

Exemple :
Classe de base : Animal avec un constructeur qui prend un
string n.
Classe dérivée : Chien qui appelle le constructeur de
Animal.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 12/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Constructeur et Héritage

Exemple de code :
class Animal {
public:
Animal(string n) { cout « "Animal créé : " « n «
endl; }
};
class Chien : public Animal {
public:
Chien(string n) : Animal(n) { cout « "Chien créé
: " « n « endl; }
};
Le constructeur de Chien appelle le constructeur de Animal.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 13/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Types d’Héritage

Il existe plusieurs types d’héritage en C++ :

Héritage public : Les membres publics et protégés de la
classe de base deviennent publics et protégés dans la classe
dérivée.
Héritage protégé : Les membres publics et protégés de la
classe de base deviennent protégés dans la classe dérivée.
Héritage privé : Les membres publics et protégés de la classe
de base deviennent privés dans la classe dérivée.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 14/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Types d’Héritage

Exemple :
class Animal {
public:
void parler() { cout « "Je suis un animal" «
endl; }
};
class Chien : private Animal {
public:
void aboyer() { cout « "Le chien aboie !" « endl;
}
};
Dans cet exemple, l’héritage est privé.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 15/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Contrôle d’Accès en Héritage

Le contrôle d’accès en C++ permet de définir la visibilité des

membres hérités :
public : Les membres publics de la classe de base sont
accessibles depuis la classe dérivée et à l’extérieur.
protected : Les membres protégés de la classe de base sont
accessibles uniquement dans la classe dérivée et ses classes
filles.
private : Les membres privés de la classe de base ne sont
accessibles que dans la classe de base.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 16/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Contrôle d’Accès en Héritage

Exemple :
class Animal {
protected:
int age;
};
class Chien : public Animal {
public:
void afficherAge() { cout « "Age : " « age «
endl; }
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 17/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Héritage Privé
L’héritage privé permet de restreindre l’accès aux membres de la
classe de base. Les membres publics et protégés de la classe de
base deviennent privés dans la classe dérivée. Cette technique est
utile lorsqu’on veut contrôler précisément l’accès aux
fonctionnalités de la classe de base tout en réutilisant le code.
Héritage privé : Modifie la visibilité des membres hérités.
Les membres public et protected de la classe de base
deviennent private dans la classe dérivée.
Contrôle strict : Permet de protéger les membres hérités
contre un accès direct.
Cela peut être utile si vous ne voulez pas que certaines parties de
la classe de base soient accessibles de l’extérieur, mais souhaitez
toujours les utiliser dans la classe dérivée.
Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 18/60
 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Héritage Privé
Voici l’exemple où nous avons une classe Animal avec un membre
public et un membre protected hérités par la classe Chien via
un héritage privé.
Animal : La classe de base.
Chien : La classe dérivée utilisant l’héritage privé.
Code de la classe de base :
class Animal {
public:
int age;
void parler() { cout « "Je parle" « endl; }
protected:
string espece;
};
Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 19/60
 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Héritage Privé

Code de la classe dérivée :

class Chien : private Animal {
public:
void afficherAge() { cout « "Age du chien : " «
age « endl; }
void afficherEspece() { cout « "Espece : " «
espece « endl; }
};
Ici, age est accessible dans la classe dérivée Chien, mais il n’est
pas accessible de l’extérieur.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 20/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Comportement et Limites de l’Héritage Privé

Lorsque vous utilisez l’héritage privé, les membres public et

protected de la classe de base deviennent privés dans la classe
dérivée. Cela empêche l’accès direct à ces membres depuis
l’extérieur, mais vous pouvez toujours les utiliser dans la classe
dérivée pour effectuer des opérations.
Les membres age et parler() sont hérités de la classe
Animal, mais sont privés dans Chien.
Vous pouvez toujours les utiliser dans Chien comme age dans
afficherAge().
Cependant, il est impossible d’accéder directement à age ou
parler() de l’extérieur de Chien.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 21/60

 Introduction
Héritage
Définition
Polymorphisme
Aspects Syntaxiques
Classes Abstraites
Contrôle d’Accès
Interfaces et Héritage multiple
Conclusion

Comportement et Limites de l’Héritage Privé

Code d’utilisation :
Chien c;
[Link](); // Affiche l’âge du chien, mais
pas accès direct à age
[Link](); // Affiche l’espèce, mais pas
accès direct à espece
Limite importante : age et espece sont privés dans Chien, ils
ne peuvent pas être accédés directement depuis l’extérieur.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 22/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Polymorphisme

Le polymorphisme est un concept clé de la programmation

orientée objet (POO) qui permet à des objets de différentes classes
d’être traités de manière uniforme. Cela permet d’utiliser la même
interface pour des types de données différents.
En C++, le polymorphisme est généralement réalisé à l’aide des
fonctions virtuelles.
Le polymorphisme permet de manipuler des objets d’une
classe de manière générique.
Il repose sur l’utilisation de fonctions virtuelles qui peuvent
être redéfinies dans des classes dérivées.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 23/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Fonctions Virtuelles

Une fonction virtuelle est une fonction membre d’une classe de

base qui peut être redéfinie dans les classes dérivées. Lorsqu’une
fonction virtuelle est appelée, C++ détermine dynamiquement la
version de la fonction à exécuter en fonction du type réel de l’objet,
et non du type auquel la référence ou le pointeur appartient.
Syntaxe : La fonction virtuelle est déclarée dans la classe de
base avec le mot-clé virtual.
Elle est redéfinie dans les classes dérivées avec override.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 24/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Exemple de Fonction Virtuelle

Exemple de base :
Nous avons une classe de base Animal avec une fonction
virtuelle parler().
Les classes dérivées Chien et Chat redéfinissent cette
fonction.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 25/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Exemple de Fonction Virtuelle

Code :
class Animal {
public:
virtual void parler() { cout « "L’animal fait un
bruit." « endl; } };
class Chien : public Animal {
public:
void parler() override { cout « "Le chien aboie."
« endl; } };
class Chat : public Animal {
public:
void parler() override { cout « "Le chat miaule."
« endl; } };
Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 26/60
 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Appel de la Fonction Virtuelle

La fonction parler() peut être appelée à travers des pointeurs ou

des références à Animal, mais la version spécifique de la fonction
appelée dépendra du type réel de l’objet.
Exécution :
Animal* a1 = new Chien();
a1->parler(); // Affiche : Le chien aboie.
Animal* a2 = new Chat();
a2->parler(); // Affiche : Le chat miaule.
C’est le polymorphisme en action : même si le type du pointeur est
Animal, la fonction appropriée est appelée.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 27/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Importance du Mécanisme de l’Appel Dynamique

En C++, lorsque vous utilisez des pointeurs ou des références vers

des objets d’une classe de base, la fonction virtuelle permet de
déterminer la version correcte de la fonction à appeler au moment
de l’exécution (appel dynamique).
Cela permet de gérer des collections d’objets de types
différents de manière uniforme.
Le polymorphisme est particulièrement utile dans les systèmes
complexes, où vous manipulez des objets ayant des
comportements variés mais des interfaces similaires.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 28/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Exemple Pratique : Classe Base et Dérivée

Code :
class Animal {
public:
virtual void parler() { cout « "Je fais un bruit
générique." « endl; }
virtual Animal() = default;
};
class Chien : public Animal {
public:
void parler() override { cout « "Le chien aboie."
« endl; }
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 29/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Exemple Pratique : Classe Base et Dérivée

class Chat : public Animal {

public:
void parler() override { cout « "Le chat miaule."
« endl; }
};
Utilisez un tableau de Animal* pour gérer des objets Chien et
Chat.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 30/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Polymorphisme avec un Tableau d’Objets

Dans cet exemple, nous créons un tableau de pointeurs Animal* et

stockons des objets de type Chien et Chat.
Code :
Animal* animaux[2];
animaux[0] = new Chien();
animaux[1] = new Chat();
for (int i = 0; i < 2; i++) {
animaux[i]->parler(); // Appel dynamique de
//parler()
}

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 31/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Polymorphisme avec un Tableau d’Objets

Exécution :
Affiche :
Le chien aboie.
Le chat miaule.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 32/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Destruction Correcte avec les Destructeurs Virtuels

Lorsqu’on utilise des fonctions virtuelles, il est essentiel de définir

un destructeur virtuel dans la classe de base. Cela garantit que les
destructeurs des classes dérivées sont appelés correctement, même
si l’objet est supprimé via un pointeur de type base.
virtual ~Animal() = default;
Cela évite les fuites de mémoire et assure que la destruction de
l’objet se fait correctement.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 33/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Avantages du Polymorphisme

Le polymorphisme et les fonctions virtuelles en C++ permettent

de :
Réutiliser le code : Les classes dérivées héritent des
fonctionnalités de la classe de base tout en modifiant certains
comportements.
Faciliter l’extension des programmes : Vous pouvez ajouter
de nouvelles classes dérivées sans modifier le code existant.
Améliorer la flexibilité et la maintenance : Le
polymorphisme rend les systèmes plus modulaires et faciles à
maintenir.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 34/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Classes Abstraites

Une classe abstraite en C++ est une classe qui contient au moins
une fonction membre purement virtuelle.
Une classe abstraite ne peut pas être instanciée directement.
Elle sert de base pour d’autres classes qui doivent
implémenter les méthodes abstraites.
Les classes abstraites sont utilisées pour créer des interfaces
communes pour des groupes d’objets différents.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 35/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Définition d’une Classe Abstraite

Pour déclarer une classe abstraite, une ou plusieurs de ses

fonctions doivent être définies comme purement virtuelles.
Une fonction purement virtuelle est déclarée en ajoutant = 0
à la déclaration de la fonction.
Exemple : virtual void afficher() = 0;
Syntaxe :
class Animal {
public:
virtual void parler() = 0; // Fonction purement
//virtuelle
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 36/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Exemple de Classe Abstraite

Exemple : La classe Forme est une classe abstraite avec une

fonction purement virtuelle aire().
class Forme {
public:
virtual double aire() = 0; // Fonction purement
//virtuelle
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 37/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Exemple de Classe Abstraite

class Rectangle : public Forme {

private:
double longueur, largeur;
public:
Rectangle(double l, double L) : longueur(l),
largeur(L)
double aire() override { return longueur *
largeur; }
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 38/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Création d’un Objet Dérivé

Une classe dérivée peut implémenter les fonctions virtuelles pures

de la classe abstraite.
Exemple : Créez un objet Rectangle et appelez la méthode
aire().
Rectangle r(5.0, 3.0);
cout « "Aire du rectangle : " « [Link](); //
Affiche : 15.0
La méthode aire() est définie dans la classe dérivée, ce qui
permet de calculer l’aire du rectangle.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 39/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Classes Abstraites pour la Réutilisation du Code

Les classes abstraites permettent de réutiliser le code en définissant

une interface commune pour différentes classes dérivées.
Une classe abstraite définit un modèle pour d’autres classes
sans fournir une implémentation complète.
Cela permet à des objets de types différents d’être traités de
manière uniforme.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 40/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Classes Abstraites pour la Réutilisation du Code

Exemple :
class Cercle : public Forme {
private:
double rayon;
public:
Cercle(double r) : rayon(r)
double aire() override { return 3.14 * rayon *
rayon; }
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 41/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Polymorphisme avec Classes Abstraites

L’utilisation de classes abstraites permet d’exploiter le
polymorphisme en C++. Cela permet d’appeler des fonctions
dérivées via des pointeurs ou des références de type classe de base.
Créez un tableau d’objets Forme*.
Utilisez des pointeurs de type Forme* pour appeler aire().
Exemple :
Forme* formes[2];
formes[0] = new Rectangle(5.0, 3.0);
formes[1] = new Cercle(2.0);
for(int i = 0; i < 2; i++) {
cout « "Aire : " « formes[i]->aire() « endl;
}
Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 42/60
 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Avantages des Classes Abstraites

L’utilisation des classes abstraites permet plusieurs avantages en

matière de réutilisation et de maintenance du code :
Encapsulation des comportements communs : Définir des
comportements généraux dans des classes de base abstraites
tout en permettant une personnalisation dans les classes
dérivées.
Réduction de la duplication de code : Les classes dérivées
partagent une interface commune et réutilisent des fonctions
sans réécrire le même code.
Flexibilité : Ajoutez de nouvelles classes dérivées sans
modifier le code des classes existantes.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 43/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Interfaces en C++

En C++, une interface est une classe qui ne contient que des
fonctions pures virtuelles.
Une interface définit un contrat : les classes dérivées
doivent implémenter toutes les fonctions de l’interface.
Contrairement à une classe abstraite, une interface ne contient
pas de données, seulement des signatures de méthodes.
Exemple d’interface :
class IParlable {
public:
virtual void parler() = 0;
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 44/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Héritage Multiple en C++

L’héritage multiple permet à une classe dérivée d’hériter de
plusieurs classes de base. Cela permet à une classe de posséder les
attributs et les comportements de plusieurs autres classes.
L’héritage multiple peut être un outil puissant, mais il doit
être utilisé avec précaution pour éviter les conflits.
En C++, une classe dérivée peut hériter de plusieurs classes
de base, y compris des interfaces.
Exemple d’héritage multiple :
class A {
public:
void afficher() { cout « "Classe A" « endl; }
};
Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 45/60
 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Héritage Multiple en C++

class B {
public:
void montrer() { cout « "Classe B" « endl; }
};
class C : public A, public B {
public:
void toutAfficher() { afficher(); montrer(); }
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 46/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Exemple Pratique : Héritage Multiple

Exemple : La classe C hérite de A et B. Elle peut appeler des

méthodes des deux classes de base.
C c;
[Link]();
Dans cet exemple :
La méthode toutAfficher() appelle les méthodes héritées
de A et B.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 47/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Interface et Héritage Multiple

Une classe peut implémenter plusieurs interfaces en C++, ce qui

est utile pour respecter plusieurs contrats tout en conservant des
implémentations distinctes.
L’interface définit des méthodes sans implémentation.
Une classe dérivée doit implémenter toutes les méthodes des
interfaces qu’elle hérite.
Exemple :
class IAffichable {
public:
virtual void afficher() = 0;
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 48/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Interface et Héritage Multiple

class IMovable {
public:
virtual void deplacer() = 0;
};
class Objet : public IAffichable, public
IMovable {
public:
void afficher() override { cout « "Objet
affiché!" « endl; }
void deplacer() override { cout « "Objet
déplacé!" « endl; }
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 49/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Utilisation des Interfaces avec Héritage Multiple

L’héritage multiple permet de combiner plusieurs interfaces dans
une seule classe dérivée, chaque interface apportant un contrat
spécifique.
Exemple :
class IA {
public:
virtual void actionA() = 0;
};
class IB {
public:
virtual void actionB() = 0;
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 50/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Utilisation des Interfaces avec Héritage Multiple

class C : public IA, public IB {

public:
void actionA() override { cout « "Action A" «
endl; }
void actionB() override { cout « "Action B" «
endl; }
};
C obj;
[Link]();
[Link]();

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 51/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Problèmes de l’Héritage Multiple : Diamant

Un problème classique de l’héritage multiple est le problème du
diamant, où une classe dérivée hérite de deux classes de base
communes, qui elles-mêmes héritent d’une même classe de base.
Le problème du diamant survient lorsque deux classes dérivées
héritent de la même classe de base, ce qui conduit à l’absence
de clarté sur l’appel des méthodes de la classe de base.
Exemple du diamant :
class A {
public:
virtual void afficher() { cout « "Classe A" «
endl; }
};
Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 52/60
 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Problèmes de l’Héritage Multiple : Diamant

class B : public A {
public:
void afficher() override { cout « "Classe B" «
endl; }
};
class C : public A {
public:
void afficher() override { cout « "Classe C" «
endl; }
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 53/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Problèmes de l’Héritage Multiple : Diamant

class D : public B, public C {

public:
void afficher() override { cout « "Classe D" «
endl; }
};
Si nous appelons D d; et [Link]();, la méthode appelée
sera ambiguë à cause du diamant.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 54/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Résolution du Problème du Diamant avec C++

Le problème du diamant peut être résolu en utilisant l’héritage
virtuel en C++.
L’héritage virtuel garantit qu’une seule instance de la classe de
base est partagée par toutes les classes dérivées.
Cela permet de résoudre les ambiguïtés en assurant qu’une
seule version des membres de la classe de base est utilisée.
Exemple avec héritage virtuel :
class A {
public:
virtual void afficher() { cout « "Classe A" «
endl; }
};
Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 55/60
 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Résolution du Problème du Diamant avec C++

class B : virtual public A {

public:
void afficher() override { cout « "Classe B" «
endl; }
};
class C : virtual public A {
public:
void afficher() override { cout « "Classe C" «
endl; }
};

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 56/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Résolution du Problème du Diamant avec C++

class D : public B, public C {

public:
void afficher() override { cout « "Classe D" «
endl; }
};
Avec l’héritage virtuel, D d; et [Link](); affichera
correctement Classe D.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 57/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Avantages de l’Héritage Multiple et des Interfaces

L’héritage multiple combiné avec des interfaces permet une grande

flexibilité dans la conception du code. Cela présente plusieurs
avantages :
Réutilisation du code : Permet de combiner les
comportements de plusieurs classes de base.
Modularité : Chaque classe peut se concentrer sur une
fonctionnalité spécifique.
Extensibilité : Facilité d’ajouter de nouvelles fonctionnalités
en utilisant des interfaces supplémentaires.
Toutefois, il faut toujours être prudent avec les conflits d’héritage
et s’assurer que l’héritage multiple est utilisé de manière judicieuse.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 58/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Points Clés à Retenir

Principe de l’héritage : Permet la création de classes

dérivées, réutilisant et étendant les fonctionnalités des classes
de base.
Aspects syntaxiques : Apprendre à définir des classes
dérivées, utiliser les constructeurs et gérer l’initialisation des
objets.
Contrôle d’accès : Savoir gérer l’accessibilité des membres
d’une classe avec les mots-clés public, protected et
private.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 59/60

 Introduction
Héritage
Polymorphisme
Classes Abstraites
Interfaces et Héritage multiple
Conclusion

Points Clés à Retenir

Polymorphisme et fonctions virtuelles : Utiliser le

polymorphisme pour un comportement dynamique et flexible
grâce aux fonctions virtuelles.
Réutilisation de code avec classes abstraites : Créer des
classes abstraites pour la réutilisation du code tout en
imposant des contrats pour les classes dérivées.
Interfaces et héritage multiple : Comprendre l’usage des
interfaces pour un design flexible et l’usage de l’héritage
multiple en C++.

Pr. Ibtissam Bakkouri Faculté Polydisciplinaire - Khouribga 60/60