Schopnost a třída k odvození vlastností a charakteristik z jiné třídy se nazývá Dědictví . Dědičnost je jednou z nejdůležitějších vlastností objektově orientovaného programování.
Dědičnost je funkce nebo proces, ve kterém se ze stávajících tříd vytvářejí nové třídy. Nově vytvořená třída se nazývá odvozená třída nebo podřízená třída a existující třída je známá jako základní třída nebo nadřazená třída. Nyní se říká, že odvozená třída je zděděna ze základní třídy.
Když říkáme, že odvozená třída dědí základní třídu, znamená to, že odvozená třída zdědí všechny vlastnosti základní třídy, aniž by měnila vlastnosti základní třídy a může přidávat nové funkce ke svým vlastním. Tyto nové funkce v odvozené třídě neovlivní základní třídu. Odvozená třída je specializovanou třídou pro základní třídu.
- Podtřída: Třída, která dědí vlastnosti z jiné třídy, se nazývá Subclass nebo Derived Class.
- Super třída: Třída, jejíž vlastnosti jsou zděděny podtřídou, se nazývá Základní třída nebo Nadtřída.
Článek je rozdělen do následujících podtémat:
- Proč a kdy použít dědičnost?
- Způsoby dědičnosti
- Typy dědičnosti
Proč a kdy použít dědičnost?
Zvažte skupinu vozidel. Musíte vytvořit třídy pro Bus, Car a Truck. Metody fuelAmount(), capacity(), applyBrakes() budou stejné pro všechny tři třídy. Pokud vytvoříme tyto třídy, abychom se vyhnuli dědičnosti, musíme všechny tyto funkce zapsat do každé ze tří tříd, jak je znázorněno na obrázku níže:
slovník c#
Jasně vidíte, že výše uvedený proces má za následek 3x duplikaci stejného kódu. To zvyšuje pravděpodobnost chyb a redundance dat. Aby se předešlo tomuto typu situace, používá se dědičnost. Pokud vytvoříme třídu Vehicle a zapíšeme do ní tyto tři funkce a zdědíme zbytek tříd z třídy vozidla, pak se můžeme jednoduše vyhnout duplicitě dat a zvýšit opětovnou použitelnost. Podívejte se na níže uvedený diagram, ve kterém jsou tři třídy zděděny z třídy vozidla:
Pomocí dědičnosti musíme funkce zapsat pouze jednou místo třikrát, protože jsme zdědili zbytek tří tříd ze základní třídy (Vehicle).
Implementace dědičnosti v C++ : Pro vytvoření podtřídy, která je zděděna ze základní třídy, musíme postupovat podle níže uvedené syntaxe.
Odvozené třídy: Odvozená třída je definována jako třída odvozená od základní třídy.
Syntax :
class : { //body }>Kde
class — klíčové slovo pro vytvoření nové třídy
odvozený_název_třídy — název nové třídy, která zdědí základní třídu
specifikátor přístupu — soukromý, veřejný nebo chráněný. Pokud není zadáno ani jedno, použije se PRIVATE jako výchozí
base-class-name — název základní třídy
Poznámka : Odvozená třída nedědí přístup členům soukromých údajů. Dědí však úplný nadřazený objekt, který obsahuje všechny soukromé členy, které daná třída deklaruje.
Příklad:
1. třída ABC : privátní XYZ //soukromé odvození
{ }
2. třída ABC : public XYZ //veřejné odvození
{ }
3. třída ABC : chráněná XYZ //chráněná derivace
{ }
4. třída ABC: XYZ //implicitně soukromá derivace
{ }
Poznámka:
o Když je základní třída soukromě zděděna odvozenou třídou, veřejné členy základní třídy se stanou soukromými členy odvozené třídy, a proto mohou být veřejné členy základní třídy přístupné pouze členskými funkcemi odvozené třídy. Jsou nepřístupné pro objekty odvozené třídy.
o Na druhou stranu, když je základní třída veřejně zděděna odvozenou třídou, veřejné členy základní třídy se také stávají veřejnými členy odvozené třídy. Veřejní členové základní třídy jsou tedy přístupní pro objekty odvozené třídy i pro členské funkce odvozené třídy.
// 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>> jméno; } void display_p() { cout<< endl <<'Id: '<< id << '
Name: ' << name <> samozřejmě; cout<< 'Enter the Course Fee:'; cin>> poplatek; } void display_s() { display_p(); cout<<'Course: '<< course << '
Fee: ' << fee << endl; } }; int main() { Student s; s.set_s(); s.display_s(); return 0; }> Výstup:
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>>jméno; } void Osoba::display_p() { cout<>samozřejmě; cout<<'Enter the Course Fee:'; cin>>poplatek; } void Student::display_s() { display_p(); cout<<'
Course: '< Výstup:
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(toto->jméno,n); } void Osoba::display_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; }> Výstup
Child id is: 7 Parent id is: 91>
Ve výše uvedeném programu je třída ‚Dítě‘ veřejně zděděna od třídy ‚Rodič‘, takže členové veřejných dat třídy ‚Rodič‘ budou také zděděni třídou ‚Dítě‘.
Způsoby dědičnosti: Existují 3 způsoby dědičnosti.
seznam do pole java
- Veřejný režim : Pokud odvodíme podtřídu z veřejné základní třídy. Poté se veřejný člen základní třídy stane veřejným v odvozené třídě a chránění členové základní třídy se stanou chráněnými v odvozené třídě.
- Chráněný režim : Pokud odvodíme podtřídu z chráněné základní třídy. Poté budou jak veřejní členové, tak chránění členové základní třídy chráněni v odvozené třídě.
- Soukromý režim : Pokud odvodíme podtřídu ze základní třídy Private. Poté se jak veřejní členové, tak chránění členové základní třídy stanou soukromými v odvozené třídě.
Poznámka: K soukromým členům v základní třídě nelze přímo přistupovat v odvozené třídě, zatímco k chráněným členům lze přistupovat přímo. Například třídy B, C a D všechny obsahují proměnné x, y a z v níže uvedeném příkladu. Je to jen otázka přístupu.
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 };>
Níže uvedená tabulka shrnuje výše uvedené tři režimy a ukazuje specifikátor přístupu členů základní třídy v podtřídě, když jsou odvozeny ve veřejném, chráněném a soukromém režimu:
Typy dědičnosti: -
- Jediné dědictví
- Víceúrovňová dědičnost
- Vícenásobná dědičnost
- Hierarchická dědičnost
- Hybridní dědičnost
Typy dědičnosti v C++
1. Jediné dědictví : Při jednoduchém dědění může třída dědit pouze z jedné třídy. tj. jedna podtřída je zděděna pouze jednou základní třídou.
Syntax :
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; }> Výstup
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<Výstup:- Zadejte hodnotu A= 3 3 Zadejte hodnotu B= 5 5 Součin 3 * 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. Vícenásobná dědičnost: Vícenásobná dědičnost je funkce jazyka C++, kde třída může dědit z více než jedné třídy. tj. jeden podtřída se dědí z více než jednoho základní třída .
Syntax :
class subclass_name : access_mode base_class1, access_mode base_class2, .... { // body of subclass }; class B { ... .. ... }; class C { ... .. ... }; class A: public B, public C { ... ... ... };>Zde bude počet základních tříd oddělen čárkou (‘, ‘) a pro každou základní třídu musí být specifikován přístupový režim.
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; }>
Výstup 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<Chcete-li se o tom dozvědět více, podívejte se na článek Vícenásobná dědictví .
3. Víceúrovňová dědičnost : Při tomto typu dědičnosti je odvozená třída vytvořena z jiné odvozené třídy.
pokud jinak bash
Syntax:-
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; }>
Výstup This is a Vehicle Objects with 4 wheels are vehicles Car has 4 Wheels>
4. Hierarchická dědičnost : Při tomto typu dědičnosti se z jedné základní třídy dědí více než jedna podtřída. tj. více než jedna odvozená třída je vytvořena z jedné základní třídy.
Syntax:-
int do řetězce java
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; }>
Výstup This is a Vehicle This is a Vehicle>
5. Hybridní (virtuální) dědičnost : Hybridní dědičnost je implementována kombinací více než jednoho typu dědičnosti. Například: Kombinace hierarchické dědičnosti a vícenásobné dědičnosti.
Níže uvedený obrázek ukazuje kombinaci hierarchického a vícenásobného dědictví:
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; }>
Výstup 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; } }; třída B : public A { protected: int b; public: void get_b() { cout<< 'Enter the value of 'b' : '; cin>>b; } }; třída C { chráněno: int c; public: void get_c() { cout<< 'Enter the value of c is : '; cin>>c; } }; třída D : public B, public C { protected: int d; public: void mul() { get_a(); get_b(); get_c(); cout<< 'Multiplication of a,b,c is : ' <
6. Speciální případ hybridní dědičnosti: Vícecestná dědičnost :
Odvozená třída se dvěma základními třídami a tyto dvě základní třídy mají jednu společnou základní třídu se nazývá vícecestná dědičnost. U tohoto typu dědictví může vzniknout nejednoznačnost.
Příklad:
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 << '
'; }>
Výstup a from ClassB : 10 a from ClassC : 100 b : 20 c : 30 d : 40>
Ve výše uvedeném příkladu ClassB i ClassC dědí ClassA, obě mají jedinou kopii ClassA. Třída-D však dědí třídu B i třídu C, a proto má třída D dvě kopie třídy A, jednu z třídy B a druhou z třídy C.
Pokud potřebujeme přistupovat k datovému členu ClassA přes objekt Class-D, musíme zadat cestu, ze které bude a bude přistupovat, ať už je to z ClassB nebo ClassC, kompilátor bcoz nedokáže rozlišit mezi dvěma kopiemi ClassA v Třída-D.
Existují 2 způsoby, jak se vyhnout této nejednoznačnosti:
1) Vyvarujte se nejednoznačnosti pomocí operátoru rozlišení rozsahu: Pomocí operátoru rozlišení rozsahu můžeme ručně zadat cestu, ze které se bude přistupovat k datovému členu a, jak je znázorněno v příkazech 3 a 4 ve výše uvedeném příkladu.
CPP obj.ClassB::a = 10; // Statement 3 obj.ClassC::a = 100; // Statement 4>
Poznámka: Přesto existují dvě kopie třídy A ve třídě D.
2) Vyhněte se nejednoznačnosti pomocí virtuální základní třídy:
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 << '
'; }> Výstup:
a : 100 b : 20 c : 30 d : 40>
Podle výše uvedeného příkladu má Třída-D pouze jednu kopii TřídyA, proto příkaz 4 přepíše hodnotu a uvedenou v příkazu 3.
