Perintö on peruskäsite OOP (olio-ohjelmointi) . Se on mekanismi, jolla yksi luokka saa periä toisen luokan ominaisuudet (kentät ja menetelmät). Periytys tarkoittaa uusien luokkien luomista olemassa olevien luokkien perusteella. Luokka, joka perii toisesta luokasta, voi käyttää uudelleen kyseisen luokan menetelmiä ja kenttiä.

Esimerkki: Seuraavassa esimerkissä Animal on perusluokka ja koirakissa ja lehmä ovat johdettuja luokkia, jotka laajentavat eläinluokkaa.

   #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  

Selitys:

• Animal on perusluokka, jossa on funktio sound().
• Dog Cat ja Cow ovat johdettuja luokkia, joista jokainen määrittelee oman sound()-menetelmänsä.
• Main() -kohdassa Dog Cat ja Cow -objektit luodaan erikseen.
• Kun kutsumme sound():ta kussakin objektissa, vastaava aliluokkametodi suoritetaan (koira haukkuu Kissa miauh Cow moos).

Syntaksi

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

Kuinka perintö toimii C++:ssa?

Kaksoispiste (:) ja an pääsyn määrittäjä käytetään periytymiseen C++:ssa. Sen avulla johdettu luokka (lapsiluokka) voi periä perusluokan (emoluokka) datajäsenet (kentät) ja jäsenfunktiot (menetelmät).
Kun luokka perii toisen luokan, se saa kaikki pääluokan käytettävissä olevat jäsenet ja aliluokka voi myös määritellä (ohita) tai lisätä niihin uusia toimintoja.

Periytystyypit C++:ssa

Alla on erityyppisiä perintöjä, joita C++ tukee.

1. Yksittäinen perintö

Yksittäisessä perinnössä alaluokka johdetaan vain yhdestä superluokasta. Se perii yhden vanhemman luokan ominaisuudet ja käyttäytymisen. Joskus sitä kutsutaan myös yksinkertaiseksi perinnöksi.

   #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. Moniperintö

sisään Moniperintö yhdellä luokalla voi olla useampi kuin yksi superluokka ja se voi periä ominaisuuksia kaikilta yläluokilta.

   #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. Monitasoinen perintö

Monitasoinen periytyminen C++:ssa tarkoittaa, että luokka on johdettu toisesta johdetusta luokasta, joka muodostaa periytymisketjun.

   #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. Hierarkkinen perintö

Hierarkkisessa perinnössä useampi kuin yksi alaluokka periytyy yhdestä perusluokasta. eli yhdestä perusluokasta luodaan useampi kuin yksi johdettu luokka. Esimerkiksi autot ja linja-autot ovat molemmat ajoneuvoja.

   #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. Hybridiperintö

Kun kaksi tai useampia perintötyyppiä yhdistetään yhteen ohjelmaan. Esimerkiksi luokka voi käyttää useita perintöjä ja olla myös osa monitasoista perintöketjua.

   #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 

Hybridiperintö voi johtaa timantti ongelma C++:ssa. Tämä tapahtuu, kun luokka perii kahdesta luokasta, jotka molemmat jakavat saman perusluokan. Tämän seurauksena johdettu luokka saa useita kopioita perusluokan jäsenistä, mikä luo epäselvyyttä siitä, mitä käyttää.

Huomautus: Ratkaisu on käyttää virtuaalista perintöä, jolloin vain yksi kopio perusluokasta jaetaan.

Perinnön edut C++:ssa

• Koodin uudelleenkäyttö : Johdettu luokka voi käyttää suoraan uudelleen perusluokkansa datajäseniä ja menetelmiä välttäen koodin päällekkäisyyttä.
• Abstraktio: Tukee abstrakteja luokkia (luokkia, joissa on puhtaita virtuaalisia toimintoja), jotka määrittävät yhteisen käyttöliittymän, joka pakottaa abstraktion.
• Luokkahierarkia: Voit rakentaa hierarkioita (perus → johdettu → edelleen johdettu) mallintaaksesi reaalimaailman suhteita.
• Polymorfismi: Tukee täysin ajonaikaista polymorfismia virtuaalisten funktioiden kautta ja myös käännösaikaista polymorfismia toimintojen ylikuormituksen ja mallien kautta.

Perinnön haitat C++:ssa

• Tiukka kytkentä: Lapsiluokka tulee riippuvaiseksi vanhempien luokasta. Kaikki muutokset perusluokissa voivat pakottaa muutoksia johdettuihin luokkiin.
• Vähentynyt joustavuus: Joskus perintöä käytetään väärin, jos koostumus (has-a-suhde) olisi parempi, mikä johtaisi vähemmän joustavaan koodiin.
• Lisääntynyt monimutkaisuus: Syvät periytymishierarkiat (monitaso tai hybridi) voivat tehdä koodin ylläpidosta ja virheenkorjauksesta vaikeasti ymmärrettävän.
• Timantti ongelma: Hybridissä tai moniperinnössä voi esiintyä epäselvyyttä, jos sama perusluokka peritään useita kertoja.
• Virtuaalisten toimintojen yleiskustannukset: Jos käytetään polymorfismia (virtuaalifunktioita), virtuaalitaulukkohakujen vuoksi ajonaikaiset kustannukset ovat pienet.