L'herència és un concepte fonamental en POO (Programació Orientada a Objectes) . És el mecanisme pel qual una classe pot heretar les característiques (camps i mètodes) d'una altra classe. L'herència significa crear noves classes a partir de les existents. Una classe que hereta d'una altra classe pot reutilitzar els mètodes i camps d'aquesta classe.

Exemple: A l'exemple següent, Animal és la classe base i Dog Cat i Cow són classes derivades que amplien 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  

Explicació:

• Animal és la classe base amb una funció sound().
• Gos, gat i vaca són classes derivades, cadascuna defineix el seu propi mètode sound().
• A main() els objectes de Dog Cat i Cow es creen per separat.
• Quan anomenem sound() a cada objecte s'executa el mètode de classe fill respectiu (El gos borda el gat miaula la vaca).

Sintaxi

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

Com funciona l'herència en C++?

Els dos punts (:) amb un especificador d'accés s'utilitza per a l'herència en C++. Permet que la classe derivada (classe secundària) hereti els membres de dades (camps) i les funcions de membre (mètodes) de la classe base (classe pare).
Quan una classe hereta una altra classe, obté tots els membres accessibles de la classe pare i la classe filla també pot redefinir (substituir) o afegir-hi noves funcionalitats.

Tipus d'herència en C++

A continuació es mostren els diferents tipus d'herència que són compatibles amb C++.

1. Herència única

En l'herència única, una subclasse es deriva només d'una superclasse. Hereta les propietats i el comportament d'una classe monoparental. De vegades també es coneix com a simple herència.

   #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. Herència múltiple

En Herència múltiple una classe pot tenir més d'una superclasse i heretar característiques de totes les classes pares.

   #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. Herència multinivell

L'herència multinivell en C++ significa que una classe es deriva d'una altra classe derivada formant una cadena d'herència.

   #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. Herència jeràrquica

En l'herència jeràrquica més d'una subclasse s'hereta d'una sola classe base. és a dir, es crea més d'una classe derivada a partir d'una única classe base. Per exemple, els cotxes i els autobusos són vehicles.

   #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. Herència híbrida

Quan dos o més tipus d'herència es combinen en un programa. Per exemple, una classe pot utilitzar l'herència múltiple i també formar part d'una cadena d'herència multinivell.

   #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'herència híbrida pot conduir a problema del diamant en C++. Això passa quan una classe hereta de dues classes que comparteixen la mateixa classe base. Com a resultat, la classe derivada obté diverses còpies dels membres de la classe base, cosa que crea ambigüitat sobre quin utilitzar.

Nota: La solució és utilitzar l'herència virtual, de manera que només es comparteix una única còpia de la classe base.

Avantatges de l'herència en C++

• Reutilitzabilitat del codi : La classe derivada pot reutilitzar directament els membres de dades i els mètodes de la seva classe base evitant la duplicació de codi.
• Abstracció: Admet classes abstractes (classes amb funcions virtuals pures) que defineixen una interfície comuna que imposa l'abstracció.
• Jerarquia de classes: Podeu crear jerarquies (base → derivats → derivats més) per modelar relacions del món real.
• Polimorfisme: Admet totalment el polimorfisme en temps d'execució mitjançant funcions virtuals i també el polimorfisme en temps de compilació mitjançant la sobrecàrrega de funcions i plantilles.

Inconvenients de l'herència en C++

• Acoblament estret: La classe fill passa a dependre de la classe pare. Qualsevol canvi en la classe base pot forçar canvis en les classes derivades.
• Flexibilitat reduïda: De vegades, l'herència s'utilitza malament quan la composició (té una relació) seria millor que condueixi a un codi menys flexible.
• Augment de la complexitat: Les jerarquies d'herència profundes (multinivell o híbrid) poden fer que el codi sigui difícil d'entendre, mantenir i depurar.
• Problema del diamant: Amb l'herència híbrida o múltiple es pot produir ambigüitat si la mateixa classe base s'hereta diverses vegades.
• Descàrrega general de les funcions virtuals: Si s'utilitza el polimorfisme (funcions virtuals), hi ha una petita sobrecàrrega de temps d'execució a causa de les cerques de taules virtuals.