Die Fähigkeit eines Klasse Eigenschaften und Merkmale aus einer anderen Klasse abzuleiten heißt Nachlass . Vererbung ist eines der wichtigsten Merkmale der objektorientierten Programmierung.
Vererbung ist eine Funktion oder ein Prozess, bei dem aus den vorhandenen Klassen neue Klassen erstellt werden. Die neu erstellte Klasse wird abgeleitete Klasse oder untergeordnete Klasse genannt und die vorhandene Klasse wird als Basisklasse oder übergeordnete Klasse bezeichnet. Die abgeleitete Klasse soll nun von der Basisklasse geerbt werden.
Wenn wir sagen, dass die abgeleitete Klasse die Basisklasse erbt, bedeutet dies, dass die abgeleitete Klasse alle Eigenschaften der Basisklasse erbt, ohne die Eigenschaften der Basisklasse zu ändern, und möglicherweise neue Funktionen zu ihrer eigenen Klasse hinzufügt. Diese neuen Funktionen in der abgeleiteten Klasse haben keine Auswirkungen auf die Basisklasse. Die abgeleitete Klasse ist die spezialisierte Klasse für die Basisklasse.
- Unterklasse: Die Klasse, die Eigenschaften von einer anderen Klasse erbt, wird Unterklasse oder abgeleitete Klasse genannt.
- Superklasse: Die Klasse, deren Eigenschaften von einer Unterklasse geerbt werden, wird Basisklasse oder Superklasse genannt.
Der Artikel ist in folgende Unterthemen unterteilt:
- Warum und wann sollte die Vererbung genutzt werden?
- Vererbungsarten
- Arten der Vererbung
Warum und wann sollte die Vererbung genutzt werden?
Betrachten Sie eine Gruppe von Fahrzeugen. Sie müssen Klassen für Bus, Auto und LKW erstellen. Die Methoden FuelAmount(), Capacity() und ApplyBrakes() sind für alle drei Klassen gleich. Wenn wir diese Klassen unter Vermeidung von Vererbung erstellen, müssen wir alle diese Funktionen in jede der drei Klassen schreiben, wie in der folgenden Abbildung dargestellt:
Was ist ein Benutzername?
Sie können deutlich erkennen, dass der obige Vorgang zu einer dreimaligen Duplizierung desselben Codes führt. Dies erhöht die Fehlerwahrscheinlichkeit und Datenredundanz. Um solche Situationen zu vermeiden, wird die Vererbung eingesetzt. Wenn wir eine Fahrzeugklasse erstellen und diese drei Funktionen darin schreiben und die restlichen Klassen von der Fahrzeugklasse erben, können wir einfach die Duplizierung von Daten vermeiden und die Wiederverwendbarkeit erhöhen. Sehen Sie sich das folgende Diagramm an, in dem die drei Klassen von der Fahrzeugklasse geerbt werden:
Mithilfe der Vererbung müssen wir die Funktionen nur einmal statt dreimal schreiben, da wir die restlichen drei Klassen von der Basisklasse (Fahrzeug) geerbt haben.
Vererbung in C++ implementieren : Um eine Unterklasse zu erstellen, die von der Basisklasse geerbt wird, müssen wir der folgenden Syntax folgen.
Abgeleitete Klassen: Eine abgeleitete Klasse ist als die von der Basisklasse abgeleitete Klasse definiert.
Syntax :
class : { //body }>Wo
class – Schlüsselwort zum Erstellen einer neuen Klasse
abgeleiteter_Klassenname – Name der neuen Klasse, die die Basisklasse erbt
Zugriffsspezifizierer – entweder privat, öffentlich oder geschützt. Wenn keines von beiden angegeben ist, wird PRIVATE als Standard verwendet
Basisklassenname – Name der Basisklasse
Notiz : Eine abgeleitete Klasse erbt nicht Zugang an private Datenelemente. Es erbt jedoch ein vollständiges übergeordnetes Objekt, das alle privaten Mitglieder enthält, die diese Klasse deklariert.
Beispiel:
1. Klasse ABC: private XYZ //private Ableitung
{ }
2. Klasse ABC: öffentliches XYZ // öffentliche Ableitung
{ }
3. Klasse ABC: geschützte XYZ // geschützte Ableitung
{ }
4. Klasse ABC: XYZ //private Ableitung standardmäßig
{ }
Notiz:
o Wenn eine Basisklasse privat von der abgeleiteten Klasse geerbt wird, werden öffentliche Mitglieder der Basisklasse zu privaten Mitgliedern der abgeleiteten Klasse und daher können nur die Mitgliedsfunktionen der abgeleiteten Klasse auf die öffentlichen Mitglieder der Basisklasse zugreifen. Sie sind für die Objekte der abgeleiteten Klasse nicht zugänglich.
o Wenn andererseits die Basisklasse öffentlich von der abgeleiteten Klasse geerbt wird, werden öffentliche Mitglieder der Basisklasse auch öffentliche Mitglieder der abgeleiteten Klasse. Daher sind die öffentlichen Mitglieder der Basisklasse sowohl für die Objekte der abgeleiteten Klasse als auch für die Mitgliedsfunktionen der abgeleiteten Klasse zugänglich.
// 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>> Name; } void display_p() { cout<< endl <<'Id: '<< id << '
Name: ' << name <> natürlich; cout<< 'Enter the Course Fee:'; cin>> Gebühr; } void display_s() { display_p(); cout<<'Course: '<< course << '
Fee: ' << fee << endl; } }; int main() { Student s; s.set_s(); s.display_s(); return 0; }> Ausgabe:
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>>Name; } void Person::display_p() { cout<>Kurs; cout<<'Enter the Course Fee:'; cin>>Gebühr; } void Student::display_s() { display_p(); cout<<'
Course: '< Ausgabe:
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 Person::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; }> Ausgabe
Child id is: 7 Parent id is: 91>
Im obigen Programm wird die Klasse „Child“ öffentlich von der Klasse „Parent“ geerbt, sodass die öffentlichen Datenmitglieder der Klasse „Parent“ auch von der Klasse „Child“ geerbt werden.
Vererbungsarten: Es gibt 3 Vererbungsarten.
- Öffentlicher Modus : Wenn wir eine Unterklasse von einer öffentlichen Basisklasse ableiten. Dann wird das öffentliche Mitglied der Basisklasse in der abgeleiteten Klasse öffentlich und geschützte Mitglieder der Basisklasse werden in der abgeleiteten Klasse geschützt.
- Sicherheitsmodus : Wenn wir eine Unterklasse von einer geschützten Basisklasse ableiten. Dann werden sowohl öffentliche als auch geschützte Mitglieder der Basisklasse in der abgeleiteten Klasse geschützt.
- Privater Modus : Wenn wir eine Unterklasse von einer privaten Basisklasse ableiten. Dann werden sowohl öffentliche als auch geschützte Mitglieder der Basisklasse in der abgeleiteten Klasse zu Private.
Notiz: Auf die privaten Mitglieder in der Basisklasse kann in der abgeleiteten Klasse nicht direkt zugegriffen werden, während auf geschützte Mitglieder direkt zugegriffen werden kann. Beispielsweise enthalten die Klassen B, C und D im folgenden Beispiel alle die Variablen x, y und z. Es ist nur eine Frage des Zugangs.
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 };>
Die folgende Tabelle fasst die oben genannten drei Modi zusammen und zeigt den Zugriffsspezifizierer der Mitglieder der Basisklasse in der Unterklasse, wenn sie im öffentlichen, geschützten und privaten Modus abgeleitet werden:
Arten der Vererbung:-
- Einzelvererbung
- Mehrstufige Vererbung
- Mehrfachvererbung
- Hierarchische Vererbung
- Hybride Vererbung
Arten der Vererbung in C++
1. Einzelvererbung : Bei der Einzelvererbung darf eine Klasse nur von einer Klasse erben. d. h. eine Unterklasse wird nur von einer Basisklasse geerbt.
Syntax :
Beispiel für einen Teilstring in Java
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; }> Ausgabe
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<Ausgabe: - Geben Sie den Wert von A=3 ein. 3 Geben Sie den Wert von B=5 ein. 5 Produkt von 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. Mehrfachvererbung: Mehrfachvererbung ist eine Funktion von C++, bei der eine Klasse von mehr als einer Klasse erben kann. d.h. eins Unterklasse wird von mehr als einem geerbt Basisklasse .
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 { ... ... ... };>Hier wird die Anzahl der Basisklassen durch ein Komma (‘, ‘) getrennt und der Zugriffsmodus für jede Basisklasse muss angegeben werden.
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; }>
Ausgabe 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<Um mehr darüber zu erfahren, lesen Sie bitte den Artikel Mehrere Erbschaften .
3. Mehrstufige Vererbung : Bei dieser Art der Vererbung wird eine abgeleitete Klasse aus einer anderen abgeleiteten Klasse erstellt.
Java-Generika
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; }>
Ausgabe This is a Vehicle Objects with 4 wheels are vehicles Car has 4 Wheels>
4. Hierarchische Vererbung : Bei dieser Art der Vererbung wird mehr als eine Unterklasse von einer einzelnen Basisklasse geerbt. d. h. es wird mehr als eine abgeleitete Klasse aus einer einzelnen Basisklasse erstellt.
Syntax:-
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; }>
Ausgabe This is a Vehicle This is a Vehicle>
5. Hybride (virtuelle) Vererbung : Hybride Vererbung wird durch die Kombination mehrerer Vererbungsarten implementiert. Beispiel: Kombination von hierarchischer Vererbung und Mehrfachvererbung.
Das folgende Bild zeigt die Kombination aus hierarchischer und mehrfacher Vererbung:
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; }>
Ausgabe 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; } }; Klasse B: public A { protected: int b; öffentlich: void get_b() { cout<< 'Enter the value of 'b' : '; cin>>b; } }; Klasse C { protected: int c; öffentlich: void get_c() { cout<< 'Enter the value of c is : '; cin>>c; } }; Klasse D: öffentlich B, öffentlich C { protected: int d; öffentlich: void mul() { get_a(); get_b(); get_c(); cout<< 'Multiplication of a,b,c is : ' <
6. Ein Sonderfall der Hybridvererbung: Multipath-Vererbung :
Eine abgeleitete Klasse mit zwei Basisklassen und diese beiden Basisklassen haben eine gemeinsame Basisklasse, wird als Mehrpfadvererbung bezeichnet. Bei dieser Art der Vererbung kann es zu Unklarheiten kommen.
Beispiel:
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 << '
'; }>
Ausgabe a from ClassB : 10 a from ClassC : 100 b : 20 c : 30 d : 40>
Im obigen Beispiel erben sowohl ClassB als auch ClassC ClassA, beide haben eine einzige Kopie von ClassA. Allerdings erbt Klasse-D sowohl KlasseB als auch KlasseC, daher verfügt Klasse-D über zwei Kopien von KlasseA, eine von KlasseB und eine andere von KlasseC.
Wenn wir über das Objekt von Klasse D auf das Datenelement von Klasse A zugreifen müssen, müssen wir den Pfad angeben, von dem aus auf a zugegriffen wird. Unabhängig davon, ob es sich um Klasse B oder Klasse C handelt, kann der bcoz-Compiler nicht zwischen zwei Kopien von Klasse A unterscheiden Klasse-D.
Es gibt zwei Möglichkeiten, diese Mehrdeutigkeit zu vermeiden:
1) Vermeidung von Mehrdeutigkeiten mithilfe des Bereichsauflösungsoperators: Mit dem Bereichsauflösungsoperator können wir manuell den Pfad angeben, von dem aus auf das Datenelement a zugegriffen wird, wie in den Anweisungen 3 und 4 im obigen Beispiel gezeigt.
CPP obj.ClassB::a = 10; // Statement 3 obj.ClassC::a = 100; // Statement 4>
Notiz: Dennoch gibt es zwei Exemplare der Klasse A in der Klasse D.
2) Vermeidung von Mehrdeutigkeiten mithilfe der virtuellen Basisklasse:
Verilog-Fallerklärung
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 << '
'; }> Ausgabe:
a : 100 b : 20 c : 30 d : 40>
Gemäß dem obigen Beispiel verfügt Klasse-D nur über eine Kopie von KlasseA, daher überschreibt Anweisung 4 den in Anweisung 3 angegebenen Wert von a.
