Héritage & polymorphisme

📄 Ressources du cours

🎥 Vidéos recommandées

• 🇫🇷 C++ #19 - héritage

  FormationVidéo · 33:53 · 13k vues — L'héritage, où la manière de définir des relations entre plusieurs classes. Voyons ensemble comment faire dériver une classe d'une autre.00:00 Introduction00...

• 🇫🇷 C++ Polymorphisme (Exemple complet avec une classe de gestion)

  Zied ALAYA · 32:06 · 11k vues — Ce tuto introduit la notion de polymorphisme en C++ et vous montre comment l'utiliser avec utilisation de constructeur de copie, destructeur et opérateur =. ...

• 🇬🇧 A Journey Into Non-Virtual Polymorphism in C++ - Rudyard Merriam - CppCon 2023

  CppCon · 48:50 · 30k vues — https://cppcon.org/---A Journey Into Non-Virtual Polymorphism addressing std::any, std::variant and visit, std::tuple and apply, and CRTP. - Rudyard Merriam ...

1. L'héritage — la relation « est un »

Exemple classique : un étudiant est une personne. Il a un nom et un prénom (de Personne), plus un numéro d'étudiant en propre.

class Personne {
   private:
      string nom;
   public:
      string getNom() const { return nom; }
};

class Etudiant : public Personne {     // Etudiant dérive de Personne
   private:
      string id;
   public:
      string getId() const { return id; }
};

La classe dérivée hérite tous les membres (données et méthodes) de la classe de base. Trois bénéfices :

• réutilisation du code déjà écrit
• ajout de nouvelles fonctionnalités spécifiques
• redéfinition d'un comportement existant

Hiérarchies simples vs multiples

Une classe peut hériter de plusieurs classes (héritage multiple) :

class A { ... };
class B { ... };
class C : public A, public B { ... };  // C hérite de A et de B

Un objet C possède simultanément les données et les méthodes de A et de B. À utiliser avec parcimonie (problème du diamant si A et B partagent un ancêtre commun).

2. Redéfinir une méthode héritée

La classe dérivée peut réécrire une méthode de la classe de base. Pour appeler la version d'origine, on préfixe avec Personne::.

class Personne {
   private: string nom;
   public:
      void afficher() const { cout << nom << endl; }
};

class Etudiant : public Personne {
   private: string id;
   public:
      void afficher() const {        // redéfinition
         Personne::afficher();           // réutilisation du parent
         cout << id << endl;             // + ajout spécifique
      }
};

3. Constructeurs et destructeurs en cascade

Quand on instancie un Etudiant, le constructeur de Personne est appelé avant celui d'Etudiant. Soit on l'appelle explicitement dans la liste d'initialisation, soit le compilateur appelle le constructeur par défaut (et râle s'il n'existe pas).

class Personne {
   private: string nom;
   public:
      Personne(string n) : nom{n} { }
};

class Etudiant : public Personne {
   private: string id;
   public:
      Etudiant(string nom, string id) : Personne(nom), id{id} { }
      //                                ↑ appel explicite du constructeur parent
};

4. Modes d'héritage — public, protected, private

Quand on dérive, on précise un mode :

class ClasseDerivee : public|protected|private ClasseBase {
   /* ... */
};

Le mode change le statut hérité des membres. Tableau des droits d'accès dans la classe dérivée :

5. Polymorphisme — choisir la bonne méthode au runtime

En C++ il s'implémente avec deux ingrédients : l'héritage et le mot-clé virtual.

Exemple — calculer une aire

class Polygon {
   protected:
      int width, height;
   public:
      virtual int getArea() { return 0; }
};

class Rectangle : public Polygon {
   public:
      int getArea() override { return width * height; }
};

class Triangle : public Polygon {
   public:
      int getArea() override { return width * height / 2; }
};

Utilisation polymorphe

vector<const Polygon*> vp;
Polygon* p1 = new Rectangle(4, 5);
Polygon* p2 = new Triangle(4, 5);
vp.push_back(p1);
vp.push_back(p2);

for (auto p : vp) {
   cout << p->getArea() << endl;    // affiche 20 puis 10
}

// n'oubliez pas delete !
delete p1; delete p2;

6. Le mot-clé override — vérification

Quand une dérivée redéfinit une virtuelle, ajouter override demande au compilateur de vérifier qu'on remplace bien quelque chose. Sans override, une faute de frappe crée silencieusement une nouvelle méthode.

class BaseClass {
   virtual void funcA();
   virtual void funcB() const = 0;
   virtual void funcC(int = 0);
   void         funcD();
};

class DerivedClass : public BaseClass {
   virtual void funcA() override;              // ✓ OK
   virtual void funcB() override;              // ✗ erreur : manque const
   virtual void funcC(double = 0.0) override;  // ✗ erreur : type ≠
   void         funcD() override;              // ✗ erreur : base non-virtuelle
};

7. Fonction virtuelle pure & classe abstraite

class Polygon {                          // classe abstraite
   protected:
      int width, height;
   public:
      virtual int getArea() = 0;          // virtuelle pure — pas de corps
};

Polygon p;       // ✗ ERREUR : classe abstraite, instanciation interdite

class Rectangle : public Polygon {
   public:
      int getArea() override { return width * height; }  // ✓ concrétisée
};

Rectangle r;     // ✓ OK : Rectangle est concrète

8. Le spécificateur final

final verrouille un mécanisme d'héritage. Deux usages :

Méthode final — interdire la redéfinition

class BaseClass {
   public:
      virtual void afficher() final {
         cout << "classe de base";
      }
};

class DerivedClass : public BaseClass {
   public:
      virtual void afficher() {           // ✗ ERREUR — afficher() est final
         cout << "classe dérivée";
      }
};

Classe final — interdire l'héritage

class BaseClass final { };

class DerivedClass : public BaseClass { };  // ✗ ERREUR — BaseClass est non-héritable

final est un mot-clé contextuel : il n'a sa signification spéciale qu'après une déclaration de méthode ou un nom de classe. Ailleurs, c'est un identifiant comme un autre.

9. Synthèse — trois types d'héritage de méthode

★ Réviser le chapitre

Pour vérifier ta compréhension

🃏 Flashcards

↻ Tout retourner

✎ Quiz éclair