Kyky a luokkaa ominaisuuksien ja ominaisuuksien johtamista toisesta luokasta kutsutaan Perintö . Periytys on yksi olio-ohjelmoinnin tärkeimmistä ominaisuuksista.
Periytys on ominaisuus tai prosessi, jossa olemassa olevista luokista luodaan uusia luokkia. Luotua uutta luokkaa kutsutaan johdetuksi luokkaksi tai aliluokkaksi ja olemassa olevaa luokkaa kutsutaan perusluokiksi tai yläluokkaksi. Johdetun luokan sanotaan nyt periytyvän perusluokasta.
Kun sanotaan, että johdettu luokka perii perusluokan, se tarkoittaa, että johdettu luokka perii kaikki perusluokan ominaisuudet muuttamatta perusluokan ominaisuuksia ja voi lisätä uusia ominaisuuksia omiinsa. Nämä johdetun luokan uudet ominaisuudet eivät vaikuta perusluokkaan. Johdettu luokka on perusluokan erikoisluokka.
- Alaluokka: Luokka, joka perii ominaisuuksia toiselta luokalta, on nimeltään alaluokka tai johdettu luokka.
- Superluokka: Luokkaa, jonka ominaisuudet alaluokka perii, kutsutaan perusluokiksi tai superluokiksi.
Artikkeli on jaettu seuraaviin ala-aiheisiin:
- Miksi ja milloin käyttää perintöä?
- Perintötavat
- Perinnön tyypit
Miksi ja milloin käyttää perintöä?
Harkitse ajoneuvoryhmää. Sinun on luotava luokat linja-autoille, henkilöautoille ja kuorma-autoille. Metodit fuelAmount(), kapasiteetti(), applyBrakes() ovat samat kaikille kolmelle luokalle. Jos luomme nämä luokat välttäen periytymistä, meidän on kirjoitettava kaikki nämä funktiot jokaiseen kolmeen luokkaan alla olevan kuvan mukaisesti:
ero illallisen ja illallisen välillä
Voit selvästi nähdä, että yllä oleva prosessi johtaa saman koodin kopioimiseen 3 kertaa. Tämä lisää virheiden ja tietojen redundanssin mahdollisuuksia. Tällaisten tilanteiden välttämiseksi käytetään perintöä. Jos luomme luokan Ajoneuvo ja kirjoitamme siihen nämä kolme funktiota ja perimme loput luokat ajoneuvoluokista, voimme yksinkertaisesti välttää tietojen päällekkäisyyden ja lisätä uudelleenkäytettävyyttä. Katso alla olevaa kaaviota, jossa kolme luokkaa on peritty ajoneuvoluokista:
Periytymistä käyttämällä meidän on kirjoitettava funktiot vain kerran kolmen sijaan, koska olemme perineet loput kolme luokkaa perusluokasta (Vehicle).
Perinnön toteuttaminen C++:ssa : Perusluokasta perityn alaluokan luomiseksi meidän on noudatettava alla olevaa syntaksia.
Johdetut luokat: Johdettu luokka määritellään perusluokasta johdetuksi luokaksi.
Syntaksi :
class : { //body }>Missä
class — avainsana uuden luokan luomiseen
derived_class_name — uuden luokan nimi, joka perii perusluokan
pääsymäärittäjä – joko yksityinen, julkinen tai suojattu. Jos kumpaakaan ei ole määritetty, oletusarvo on PRIVATE
base-class-name — perusluokan nimi
Huomautus : Johdettu luokka ei peri pääsy yksityisille datajäsenille. Se kuitenkin perii täyden yläobjektin, joka sisältää kaikki kyseisen luokan ilmoittamat yksityiset jäsenet.
Esimerkki:
1. luokka ABC : yksityinen XYZ //yksityinen johdannainen
{ }
2. luokka ABC : julkinen XYZ //julkinen johdannainen
{ }
3. luokka ABC : suojattu XYZ //suojattu johdannainen
{ }
4. luokka ABC: XYZ //yksityinen johtaminen oletuksena
{ }
Huomautus:
o Kun johdettu luokka perii perusluokan yksityisesti, perusluokan julkisista jäsenistä tulee johdetun luokan yksityisiä jäseniä ja siksi perusluokan julkisiin jäseniin pääsevät vain johdetun luokan jäsenfunktiot. Ne eivät ole johdetun luokan kohteiden käytettävissä.
o Toisaalta, kun perusluokan julkisesti perii johdettu luokka, perusluokan julkisista jäsenistä tulee myös johdetun luokan julkisia jäseniä. Siksi perusluokan julkiset jäsenet ovat saatavilla johdetun luokan objekteilla sekä johdetun luokan jäsenfunktioilla.
// Example: define member function without argument within // the class #include using namespace std; class Person { int id; char name[100]; public: void set_p() { cout << 'Enter the Id:'; cin>> id; cout<< 'Enter the Name:'; cin>> nimi; } void display_p() { cout<< endl <<'Id: '<< id << '
Name: ' << name <> kurssi; cout<< 'Enter the Course Fee:'; cin>> maksu; } void display_s() { display_p(); cout<<'Course: '<< course << '
Fee: ' << fee << endl; } }; int main() { Student s; s.set_s(); s.display_s(); return 0; }> Lähtö:
Enter the Id: 101 Enter the Name: Dev Enter the Course Name: GCS Enter the Course Fee:70000 Id: 101 Name: Dev Course: GCS Fee: 70000>C++
// Example: define member function without argument outside the class #include using namespace std; class Person { int id; char name[100]; public: void set_p(); void display_p(); }; void Person::set_p() { cout<<'Enter the Id:'; cin>> id; cout<<'Enter the Name:'; cin>> nimi; } void Henkilö::näyttö_p() { cout<> kurssi; cout<<'Enter the Course Fee:'; cin>> maksu; } void Opiskelija::näyttö_s() { näyttö_p(); cout<<'
Course: '< Lähtö:
Enter the Id: 101 Enter the Name: Dev Enter the Course Name: GCS Enter the Course Fee: 70000 Id: 101 Name: Dev Course: GCS Fee: 70000>C++
// Example: define member function with argument outside the class #include #include using namespace std; class Person { int id; char name[100]; public: void set_p(int,char[]); void display_p(); }; void Person::set_p(int id,char n[]) { this->id=id; strcpy(this->name,n); } void Henkilö::näyttö_p() { cout< CPP
// C++ program to demonstrate implementation // of Inheritance #include using namespace std; // Base class class Parent { public: int id_p; }; // Sub class inheriting from Base Class(Parent) class Child : public Parent { public: int id_c; }; // main function int main() { Child obj1; // An object of class child has all data members // and member functions of class parent obj1.id_c = 7; obj1.id_p = 91; cout << 'Child id is: ' << obj1.id_c << '
'; cout << 'Parent id is: ' << obj1.id_p << '
'; return 0; }> Lähtö
Child id is: 7 Parent id is: 91>
Yllä olevassa ohjelmassa luokka 'Lapsi' on julkisesti peritty 'Vanhempi'-luokasta, joten luokan 'Vanhempi' julkiset datajäsenet perii myös luokka 'Lapsi'.
Perintötavat: Periytymistapoja on 3.
- Julkinen tila : Jos johdetaan aliluokka julkisesta perusluokasta. Silloin perusluokan julkinen jäsen tulee julkiseksi johdetussa luokassa ja perusluokan suojatut jäsenet tulevat suojatuksi johdetussa luokassa.
- Suojattu tila : Jos johdetaan aliluokka suojatusta perusluokasta. Tällöin sekä julkiset jäsenet että suojatut perusluokan jäsenet tulevat suojatuksi johdetussa luokassa.
- Yksityinen tila : Jos johdamme aliluokan yksityisestä perusluokasta. Silloin sekä julkisista että suojatuista perusluokan jäsenistä tulee yksityisiä johdetussa luokassa.
Huomautus: Perusluokan yksityisiin jäseniin ei pääse suoraan johdetussa luokassa, kun taas suojattuihin jäseniin pääsee suoraan. Esimerkiksi luokat B, C ja D sisältävät kaikki muuttujat x, y ja z alla olevassa esimerkissä. Kysymys on vain pääsystä.
CPP // C++ Implementation to show that a derived class // doesn’t inherit access to private data members. // However, it does inherit a full parent object. class A { public: int x; protected: int y; private: int z; }; class B : public A { // x is public // y is protected // z is not accessible from B }; class C : protected A { // x is protected // y is protected // z is not accessible from C }; class D : private A // 'private' is default for classes { // x is private // y is private // z is not accessible from D };>
Alla olevassa taulukossa on yhteenveto edellä mainituista kolmesta tilasta ja näytetään alaluokan perusluokan jäsenten pääsymääritykset, kun ne on johdettu julkisissa, suojatuissa ja yksityisissä tiloissa:
merkkijono päivämäärään muuntaa
Perinnön tyypit: -
- Yksittäinen perintö
- Monitasoinen perintö
- Moniperintö
- Hierarkkinen perintö
- Hybridiperintö
Periytystyypit C++:ssa
1. Yksittäinen perintö : Yksittäisessä perinnössä luokka saa periä vain yhdestä luokasta. eli yhden alaluokan perii vain yksi perusluokka.
Syntaksi :
class subclass_name : access_mode base_class { // body of subclass }; OR class A { ... .. ... }; class B: public A { ... .. ... };>CPP // C++ program to explain // Single inheritance #include using namespace std; // base class class Vehicle { public: Vehicle() { cout << 'This is a Vehicle
'; } }; // sub class derived from a single base classes class Car : public Vehicle { }; // main function int main() { // Creating object of sub class will // invoke the constructor of base classes Car obj; return 0; }> Lähtö
This is a Vehicle>
C++
// Example: #include using namespace std; class A { protected: int a; public: void set_A() { cout<<'Enter the Value of A='; cin>>a; } void disp_A() { cout<Tulos: - Syötä arvo A= 3 3 Syötä arvo B= 5 5 3:n tulo * 5 = 15
C++ // Example: #include using namespace std; class A { protected: int a; public: void set_A(int x) { a=x; } void disp_A() { cout<Product of 4 * 5 = 20>
2. Moniperintö: Multiple Heritance on C++:n ominaisuus, jossa luokka voi periä useammasta kuin yhdestä luokasta. eli yksi alaluokka on peritty useammalta kuin yhdeltä perusluokka .
Syntaksi :
class subclass_name : access_mode base_class1, access_mode base_class2, .... { // body of subclass }; class B { ... .. ... }; class C { ... .. ... }; class A: public B, public C { ... ... ... };>Tässä perusluokkien määrä erotetaan pilkulla (', ') ja jokaisen perusluokan pääsytila on määritettävä.
CPP // C++ program to explain // multiple inheritance #include using namespace std; // first base class class Vehicle { public: Vehicle() { cout << 'This is a Vehicle
'; } }; // second base class class FourWheeler { public: FourWheeler() { cout << 'This is a 4 wheeler Vehicle
'; } }; // sub class derived from two base classes class Car : public Vehicle, public FourWheeler { }; // main function int main() { // Creating object of sub class will // invoke the constructor of base classes. Car obj; return 0; }>
Lähtö This is a Vehicle This is a 4 wheeler Vehicle>
C++ // Example: #include using namespace std; class A { protected: int a; public: void set_A() { cout<<'Enter the Value of A='; cin>>a; } void disp_A() { cout<Lisätietoja siitä saat artikkelista Useita perintöjä .
3. Monitasoinen perintö : Tämän tyyppisessä perinnössä johdettu luokka luodaan toisesta johdetusta luokasta.
bash for loop
Syntaksi:-
class C { ... .. ... }; class B:public C { ... .. ... }; class A: public B { ... ... ... };>CPP // C++ program to implement // Multilevel Inheritance #include using namespace std; // base class class Vehicle { public: Vehicle() { cout << 'This is a Vehicle
'; } }; // first sub_class derived from class vehicle class fourWheeler : public Vehicle { public: fourWheeler() { cout << 'Objects with 4 wheels are vehicles
'; } }; // sub class derived from the derived base class fourWheeler class Car : public fourWheeler { public: Car() { cout << 'Car has 4 Wheels
'; } }; // main function int main() { // Creating object of sub class will // invoke the constructor of base classes. Car obj; return 0; }>
Lähtö This is a Vehicle Objects with 4 wheels are vehicles Car has 4 Wheels>
4. Hierarkkinen perintö : Tämäntyyppisessä perinnössä useampi kuin yksi alaluokka periytyy yhdestä perusluokasta. eli yhdestä perusluokasta luodaan useampi kuin yksi johdettu luokka.
Syntaksi:-
class A { // body of the class A. } class B : public A { // body of class B. } class C : public A { // body of class C. } class D : public A { // body of class D. }>CPP // C++ program to implement // Hierarchical Inheritance #include using namespace std; // base class class Vehicle { public: Vehicle() { cout << 'This is a Vehicle
'; } }; // first sub class class Car : public Vehicle { }; // second sub class class Bus : public Vehicle { }; // main function int main() { // Creating object of sub class will // invoke the constructor of base class. Car obj1; Bus obj2; return 0; }>
Lähtö This is a Vehicle This is a Vehicle>
5. Hybridi (virtuaalinen) perintö : Hybridiperintö toteutetaan yhdistämällä useampi kuin yksi perintötyyppi. Esimerkiksi: Hierarkkisen perinnön ja moniperinnön yhdistäminen.
Alla olevassa kuvassa näkyy hierarkkisten ja useiden perintöjen yhdistelmä:
CPP // C++ program for Hybrid Inheritance #include using namespace std; // base class class Vehicle { public: Vehicle() { cout << 'This is a Vehicle
'; } }; // base class class Fare { public: Fare() { cout << 'Fare of Vehicle
'; } }; // first sub class class Car : public Vehicle { }; // second sub class class Bus : public Vehicle, public Fare { }; // main function int main() { // Creating object of sub class will // invoke the constructor of base class. Bus obj2; return 0; }>
Lähtö This is a Vehicle Fare of Vehicle>
C++ // Example: #include using namespace std; class A { protected: int a; public: void get_a() { cout << 'Enter the value of 'a' : '; cin>>a; } }; luokka B : julkinen A { suojattu: int b; julkinen: void get_b() { cout<< 'Enter the value of 'b' : '; cin>>b; } }; luokka C { suojattu: int c; julkinen: void get_c() { cout<< 'Enter the value of c is : '; cin>>c; } }; luokka D : julkinen B, julkinen C { suojattu: int d; public: void mul() { get_a(); get_b(); get_c(); cout<< 'Multiplication of a,b,c is : ' <
6. Hybridiperinnön erikoistapaus: Monitieperintö :
Johdettua luokkaa, jossa on kaksi perusluokkaa ja näillä kahdella perusluokalla on yksi yhteinen perusluokka, kutsutaan monitieperitykseksi. Tämäntyyppisessä perinnössä voi syntyä epäselvyyttä.
Esimerkki:
CPP // C++ program demonstrating ambiguity in Multipath // Inheritance #include using namespace std; class ClassA { public: int a; }; class ClassB : public ClassA { public: int b; }; class ClassC : public ClassA { public: int c; }; class ClassD : public ClassB, public ClassC { public: int d; }; int main() { ClassD obj; // obj.a = 10; // Statement 1, Error // obj.a = 100; // Statement 2, Error obj.ClassB::a = 10; // Statement 3 obj.ClassC::a = 100; // Statement 4 obj.b = 20; obj.c = 30; obj.d = 40; cout << ' a from ClassB : ' << obj.ClassB::a; cout << '
a from ClassC : ' << obj.ClassC::a; cout << '
b : ' << obj.b; cout << '
c : ' << obj.c; cout << '
d : ' << obj.d << '
'; }>
Lähtö a from ClassB : 10 a from ClassC : 100 b : 20 c : 30 d : 40>
Yllä olevassa esimerkissä sekä ClassB että ClassC perivät ClassA:n, molemmilla on yksi kopio ClassA:sta. Luokka D kuitenkin perii sekä ClassB:n että ClassC:n, joten D:llä on kaksi kopiota ClassA:sta, yksi ClassB:sta ja toinen ClassC:stä.
Jos meidän on päästävä ClassA:n datajäseneen luokan D objektin kautta, meidän on määritettävä polku, josta a:ta käytetään, onko se luokasta B vai ClassC, bcoz-kääntäjä ei pysty erottamaan kahta ClassA:n kopiota. Luokka-D.
On 2 tapaa välttää tämä epäselvyys:
1) Epäselvyyden välttäminen kaukoresoluutiooperaattorilla: Käyttämällä laajuuden resoluutiooperaattoria voimme määrittää manuaalisesti polun, josta datajäseneen a päästään, kuten yllä olevan esimerkin lauseissa 3 ja 4 on esitetty.
CPP obj.ClassB::a = 10; // Statement 3 obj.ClassC::a = 100; // Statement 4>
Huomautus: Luokassa D on kuitenkin kaksi kopiota ClassA:sta.
2) Epäselvyyden välttäminen käyttämällä virtuaalista perusluokkaa:
nuhjuinen piste
CPP #include class ClassA { public: int a; }; class ClassB : virtual public ClassA { public: int b; }; class ClassC : virtual public ClassA { public: int c; }; class ClassD : public ClassB, public ClassC { public: int d; }; int main() { ClassD obj; obj.a = 10; // Statement 3 obj.a = 100; // Statement 4 obj.b = 20; obj.c = 30; obj.d = 40; cout << '
a : ' << obj.a; cout << '
b : ' << obj.b; cout << '
c : ' << obj.c; cout << '
d : ' << obj.d << '
'; }> Lähtö:
a : 100 b : 20 c : 30 d : 40>
Yllä olevan esimerkin mukaan luokassa D on vain yksi kopio luokasta A, joten lause 4 korvaa käskyssä 3 annetun a:n arvon.
