Moștenirea este un concept fundamental în OOP (programare orientată pe obiecte) . Este mecanismul prin care unei clase i se permite să moștenească caracteristicile (câmpurile și metodele) unei alte clase. Moștenirea înseamnă crearea de noi clase pe baza celor existente. O clasă care moștenește de la o altă clasă poate reutiliza metodele și câmpurile acelei clase.

Exemplu: În exemplul următor, Animalul este clasa de bază, iar Câinele, Pisica și Vaca sunt clase derivate care extind clasa 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  

Explicaţie:

• Animal este clasa de bază cu o funcție sound().
• Câine, pisică și vaca sunt clase derivate, fiecare definindu-și propria metodă sound().
• În main() obiectele Dog Cat și Cow sunt create separat.
• Când apelăm sound() pe fiecare obiect, rulează metoda clasei copil respectiv (Dog barks Cat meaws Cow moos).

Sintaxă

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

Cum funcționează moștenirea în C++?

Colonul (:) cu un specificatorul de acces este folosit pentru moștenire în C++. Permite clasei derivate (clasa copil) să moștenească membrii de date (câmpuri) și funcțiile membre (metode) ale clasei de bază (clasa părinte).
Când o clasă moștenește o altă clasă, primește toți membrii accesibili ai clasei părinte, iar clasa copil poate, de asemenea, să redefiniți (supracrieți) sau să le adauge o nouă funcționalitate.

Tipuri de moștenire în C++

Mai jos sunt diferitele tipuri de moștenire care sunt acceptate de C++.

1. Moștenire unică

În moștenirea unică, o sub-clasă este derivată dintr-o singură super-clasă. Moștenește proprietățile și comportamentul unei clase monoparentale. Uneori este cunoscută și ca moștenire simplă.

   #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. Moștenirea multiplă

În Moștenire multiplă o clasă poate avea mai multe superclase și poate moșteni caracteristici de la toate clasele părinte.

   #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. Moștenirea pe mai multe niveluri

Moștenirea pe mai multe niveluri în C++ înseamnă că o clasă este derivată dintr-o altă clasă derivată formând un lanț de moștenire.

   #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. Moștenirea ierarhică

În moștenirea ierarhică, mai multe subclase sunt moștenite de la o singură clasă de bază. adică mai mult de o clasă derivată este creată dintr-o singură clasă de bază. De exemplu, mașinile și autobuzele sunt ambele vehicule.

   #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. Moștenirea hibridă

Când două sau mai multe tipuri de moștenire sunt combinate într-un singur program. De exemplu, o clasă poate folosi moștenirea multiplă și, de asemenea, poate face parte dintr-un lanț de moștenire pe mai multe niveluri.

   #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 

Moștenirea hibridă poate duce la problema diamantelor în C++. Acest lucru se întâmplă atunci când o clasă moștenește din două clase care împărtășesc aceeași clasă de bază. Ca rezultat, clasa derivată primește mai multe copii ale membrilor clasei de bază, ceea ce creează ambiguitate cu privire la care să folosească.

Notă: Soluția este să folosiți moștenirea virtuală, astfel încât să fie partajată doar o singură copie a clasei de bază.

Avantajele moștenirii în C++

• Reutilizarea codului : Clasa derivată poate reutiliza direct membrii de date și metodele clasei sale de bază evitând duplicarea codului.
• Abstracție: Suportă clase abstracte (clase cu funcții virtuale pure) care definesc o interfață comună care impune abstractizarea.
• Ierarhia clasei: Puteți construi ierarhii (de bază → derivate → derivate în continuare) pentru a modela relațiile din lumea reală.
• Polimorfism: Suporta pe deplin polimorfismul runtime prin funcții virtuale și, de asemenea, polimorfismul în timp de compilare prin supraîncărcare de funcții și șabloane.

Dezavantajele moștenirii în C++

• Cuplaje strânse: Clasa copil devine dependentă de clasa părinte. Orice modificare a clasei de bază poate forța modificări în clasele derivate.
• Flexibilitate redusă: Uneori, moștenirea este folosită greșit în cazul în care compoziția (are-o relație) ar fi mai bine să conducă la un cod mai puțin flexibil.
• Complexitate crescută: Ierarhiile profunde de moștenire (multinivel sau hibrid) pot face ca codul să fie greu de înțeles întreținerea și depanarea.
• Problema diamantului: Cu moștenirea hibridă sau multiplă, poate apărea ambiguitatea dacă aceeași clasă de bază este moștenită de mai multe ori.
• Suprafața funcțiilor virtuale: Dacă se folosește polimorfismul (funcții virtuale), există o mică suprasarcină de rulare din cauza căutărilor în tabelele virtuale.