Az öröklődés alapvető fogalom OOP (objektumorientált programozás) . Ez az a mechanizmus, amellyel az egyik osztály örökölheti egy másik osztály jellemzőit (mezőit és metódusait). Az öröklődés új osztályok létrehozását jelenti a meglévők alapján. Egy másik osztálytól örökölt osztály újra felhasználhatja az adott osztály metódusait és mezőit.

Példa: A következő példában az Állat az alaposztály, a Kutya macska és a Tehén pedig származtatott osztályok, amelyek kiterjesztik az Állat osztályt.

   #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  

Magyarázat:

• Az Animal az alaposztály egy sound() funkcióval.
• A Dog Cat és a Cow származtatott osztályok, amelyek mindegyike meghatározza a saját hang() metódusát.
• A main()-ban a Dog Cat és a Cow objektumai külön jönnek létre.
• Amikor minden objektumon meghívjuk a sound()-t, a megfelelő gyermekosztály metódus fut le (Kutya ugat Macska nyávog Cow moos).

Szintaxis

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

Hogyan működik az öröklődés a C++ nyelven?

A kettőspont (:) egy hozzáférés-specifikátor a C++-ban öröklésre használatos. Lehetővé teszi, hogy a származtatott osztály (gyermekosztály) örökölje az alaposztály (szülőosztály) adattagjait (mezőit) és tagfüggvényeit (metódusait).
Amikor egy osztály egy másik osztályt örököl, megkapja a szülő osztály összes elérhető tagját, és az utódosztály is újradefiniálhatja (felülbírálhatja) vagy új funkciókat adhat hozzá.

Az öröklődés típusai a C++ nyelven

Az alábbiakban bemutatjuk a C++ által támogatott különböző öröklődési típusokat.

1. Egyszeri öröklődés

Egyetlen öröklődés esetén egy alosztály csak egy szuperosztályból származik. Egyszülős osztály tulajdonságait és viselkedését örökli. Néha egyszerű öröklődésnek is nevezik.

   #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. Többszörös öröklés

In Többszörös öröklés egy osztálynak több szuperosztálya is lehet, és örökölheti az összes szülőosztály jellemzőit.

   #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. Többszintű öröklődés

A többszintű öröklődés a C++ nyelvben azt jelenti, hogy egy osztály egy másik származtatott osztályból származik, amely öröklési láncot alkot.

   #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. Hierarchikus öröklődés

A hierarchikus öröklés során egynél több alosztály öröklődik egyetlen alaposztályból. azaz egyetlen alaposztályból több származtatott osztály jön létre. Például az autók és a buszok egyaránt járművek.

   #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. Hibrid öröklődés

Ha két vagy több típusú öröklődést kombinálnak egy programban. Például egy osztály használhat többszörös öröklődést, és egy többszintű öröklődési lánc része is lehet.

   #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 

A hibrid öröklődés a gyémánt probléma C++ nyelven. Ez akkor fordul elő, ha egy osztály két olyan osztályból örököl, amelyek ugyanazon az alaposztályon osztoznak. Ennek eredményeként a származtatott osztály több másolatot kap az alaposztály tagjairól, ami kétértelművé teszi, hogy melyiket használja.

Megjegyzés: A megoldás a virtuális öröklés használata, így az alaposztálynak csak egyetlen példánya lesz megosztva.

Az öröklődés előnyei C++ nyelven

• Kód újrafelhasználhatósága : A származtatott osztály közvetlenül újra felhasználhatja alaposztályának adattagjait és metódusait, elkerülve a kódduplikációt.
• Absztrakció: Támogatja az absztrakt osztályokat (tisztán virtuális függvényekkel rendelkező osztályokat), amelyek közös interfészt határoznak meg az absztrakció végrehajtására.
• Osztályhierarchia: A valós kapcsolatok modellezéséhez hierarchiákat építhet (alap → származtatott → tovább származtatott).
• Polimorfizmus: Teljes mértékben támogatja a futásidejű polimorfizmust a virtuális függvényeken keresztül, valamint a fordítási idejű polimorfizmust a függvénytúlterhelés és a sablonok révén.

Az öröklődés hátrányai C++ nyelven

• Szoros csatlakozás: A gyermekosztály a szülő osztálytól válik függővé. Bármilyen változás az alaposztályban, megváltoztathatja a származtatott osztályokat.
• Csökkentett rugalmasság: Néha az örökléssel visszaélnek, ahol az összetétel (has-a kapcsolat) jobb lenne, ami kevésbé rugalmas kódhoz vezetne.
• Fokozott összetettség: A mély öröklődési hierarchiák (többszintű vagy hibrid) megnehezíthetik a kód megértését, karbantartását és hibakeresését.
• Gyémánt probléma: Hibrid vagy többszörös öröklődés esetén kétértelműség fordulhat elő, ha ugyanaz az alaposztály többször öröklődik.
• A virtuális funkciók rezsije: Ha polimorfizmust (virtuális függvényeket) használunk, akkor a virtuális tábla keresései miatt kis futási többletköltség keletkezik.