L'héritage est un concept fondamental dans POO (Programmation Orientée Objet) . C'est le mécanisme par lequel une classe est autorisée à hériter des fonctionnalités (champs et méthodes) d'une autre classe. L'héritage signifie créer de nouvelles classes basées sur celles existantes. Une classe qui hérite d'une autre classe peut réutiliser les méthodes et les champs de cette classe.

Exemple: Dans l'exemple suivant, Animal est la classe de base et Dog Cat et Cow sont des classes dérivées qui étendent la classe Animal.

   #include          using     namespace     std  ;   class     Animal   {      public  :      void     sound  ()      {      cout      < <     'Animal makes a sound'      < <     endl  ;      }   };   class     Dog     :     public     Animal   {      public  :      void     sound  ()      {      cout      < <     'Dog barks'      < <     endl  ;      }   };   class     Cat     :     public     Animal   {      public  :      void     sound  ()      {      cout      < <     'Cat meows'      < <     endl  ;      }   };   class     Cow     :     public     Animal   {      public  :      void     sound  ()      {      cout      < <     'Cow moos'      < <     endl  ;      }   };   int     main  ()   {      Dog     d  ;      d  .  sound  ();      Cat     c  ;      c  .  sound  ();      Cow     cow  ;      cow  .  sound  ();      return     0  ;   }   

Dog barks Cat meows Cow moos  

Explication:

• Animal est la classe de base avec une fonction sound().
• Dog Cat et Cow sont des classes dérivées définissant chacune leur propre méthode sound().
• Dans main(), les objets Dog Cat et Cow sont créés séparément.
• Lorsque nous appelons sound() sur chaque objet, la méthode de classe enfant respective s'exécute (le chien aboie, le chat miaule, la vache meugle).

Syntaxe

   class     ChildClass     :     public     ParentClass   {      // Additional fields and methods   };   

Comment fonctionne l’héritage en C++ ?

Les deux points (:) avec un spécificateur d'accès est utilisé pour l’héritage en C++. Il permet à la classe dérivée (classe enfant) d'hériter des données membres (champs) et des fonctions membres (méthodes) de la classe de base (classe parent).
Lorsqu'une classe hérite d'une autre classe, elle obtient tous les membres accessibles de la classe parent et la classe enfant peut également les redéfinir (remplacer) ou leur ajouter de nouvelles fonctionnalités.

Types d'héritage en C++

Vous trouverez ci-dessous les différents types d'héritage pris en charge par C++.

1. Héritage unique

Dans l'héritage simple, une sous-classe est dérivée d'une seule super-classe. Il hérite des propriétés et du comportement d'une classe monoparentale. Parfois, on parle également d’héritage simple.

   #include          using     namespace     std  ;   class     Vehicle     {   public  :      Vehicle  ()     {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   class     Car     :     public     Vehicle     {   public  :      Car  ()     {      cout      < <     'This Vehicle is Car'      < <     endl  ;      }   };   int     main  ()     {          Car     obj  ;      return     0  ;   }   

This is a Vehicle This Vehicle is Car  

2. Héritage multiple

Dans Héritage multiple une classe peut avoir plusieurs superclasses et hériter des fonctionnalités de toutes les classes parentes.

   #include          using     namespace     std  ;   class     LandVehicle   {      public  :      void     landInfo  ()      {      cout      < <     'This is a LandVehicle'      < <     endl  ;      }   };   class     WaterVehicle   {      public  :      void     waterInfo  ()      {      cout      < <     'This is a WaterVehicle'      < <     endl  ;      }   };   // Derived class inheriting from both base classes   class     AmphibiousVehicle     :     public     LandVehicle       public     WaterVehicle   {      public  :      AmphibiousVehicle  ()      {      cout      < <     'This is an AmphibiousVehicle'      < <     endl  ;      }   };   int     main  ()   {      AmphibiousVehicle     obj  ;      obj  .  waterInfo  ();      obj  .  landInfo  ();      return     0  ;   }   

This is an AmphibiousVehicle This is a WaterVehicle This is a LandVehicle  

3. Héritage à plusieurs niveaux

L'héritage multiniveau en C++ signifie qu'une classe est dérivée d'une autre classe dérivée formant une chaîne d'héritage.

   #include          using     namespace     std  ;   class     Vehicle   {      public  :      Vehicle  ()      {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   // Derived class from Vehicle   class     FourWheeler     :     public     Vehicle   {      public  :      FourWheeler  ()      {      cout      < <     '4 Wheeler Vehicles'      < <     endl  ;      }   };   // Derived class from FourWheeler   class     Car     :     public     FourWheeler   {      public  :      Car  ()      {      cout      < <     'This 4 Wheeler Vehicle is a Car'      < <     endl  ;      }   };   int     main  ()   {      Car     obj  ;      return     0  ;   }   

This is a Vehicle 4 Wheeler Vehicles This 4 Wheeler Vehicle is a Car  

4. Héritage hiérarchique

Dans l'héritage hiérarchique, plusieurs sous-classes sont héritées d'une seule classe de base. c'est-à-dire que plusieurs classes dérivées sont créées à partir d'une seule classe de base. Par exemple, les voitures et les bus sont tous deux des véhicules.

   #include          using     namespace     std  ;   class     Vehicle   {      public  :      Vehicle  ()      {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   class     Car     :     public     Vehicle   {      public  :      Car  ()      {      cout      < <     'This Vehicle is Car'      < <     endl  ;      }   };   class     Bus     :     public     Vehicle   {      public  :      Bus  ()      {      cout      < <     'This Vehicle is Bus'      < <     endl  ;      }   };   int     main  ()   {      Car     obj1  ;      Bus     obj2  ;      return     0  ;   }   

This is a Vehicle This Vehicle is Car This is a Vehicle This Vehicle is Bus  

5. Héritage hybride

Lorsque deux ou plusieurs types d'héritage sont combinés dans un seul programme. Par exemple, une classe peut utiliser l'héritage multiple et également faire partie d'une chaîne d'héritage à plusieurs niveaux.

   #include          using     namespace     std  ;   class     Vehicle   {      public  :      Vehicle  ()      {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   class     Fare   {      public  :      Fare  ()      {      cout      < <     'Fare of Vehicle'      < <     endl  ;      }   };   class     Car     :     public     Vehicle   {      public  :      Car  ()      {      cout      < <     'This Vehical is a Car'      < <     endl  ;      }   };   class     Bus     :     public     Vehicle       public     Fare   {      public  :      Bus  ()      {      cout      < <     'This Vehicle is a Bus with Fare'  ;      }   };   int     main  ()   {      Bus     obj2  ;      return     0  ;   }   

This is a Vehicle Fare of Vehicle This Vehicle is a Bus with Fare 

L'héritage hybride peut conduire à problème de diamant en C++. Cela se produit lorsqu’une classe hérite de deux classes partageant toutes deux la même classe de base. En conséquence, la classe dérivée obtient plusieurs copies des membres de la classe de base, ce qui crée une ambiguïté quant à savoir lequel utiliser.

Note : La solution consiste à utiliser l'héritage virtuel afin qu'une seule copie de la classe de base soit partagée.

Avantages de l'héritage en C++

• Réutilisabilité du code : La classe dérivée peut réutiliser directement les données membres et les méthodes de sa classe de base en évitant la duplication de code.
• Abstraction : Prend en charge les classes abstraites (classes avec des fonctions virtuelles pures) qui définissent une interface commune appliquant l'abstraction.
• Hiérarchie des classes : Vous pouvez créer des hiérarchies (base → dérivée → dérivée ultérieure) pour modéliser les relations du monde réel.
• Polymorphisme : Prend entièrement en charge le polymorphisme d'exécution via des fonctions virtuelles ainsi que le polymorphisme au moment de la compilation via la surcharge de fonctions et les modèles.

Inconvénients de l'héritage en C++

• Couplage serré : La classe enfant devient dépendante de la classe parent. Tout changement dans la classe de base peut forcer des changements dans les classes dérivées.
• Flexibilité réduite : Parfois, l'héritage est mal utilisé là où la composition (a une relation) serait meilleure, conduisant à un code moins flexible.
• Complexité accrue : Les hiérarchies d'héritage profondes (à plusieurs niveaux ou hybrides) peuvent rendre le code difficile à comprendre, à maintenir et à déboguer.
• Problème de diamant : Avec l'héritage hybride ou multiple, une ambiguïté peut survenir si la même classe de base est héritée plusieurs fois.
• Overhead des fonctions virtuelles : Si le polymorphisme (fonctions virtuelles) est utilisé, il y a une petite surcharge d'exécution due aux recherches de tables virtuelles.