In C++ is overerving een proces waarbij één object automatisch alle eigenschappen en gedragingen van het bovenliggende object verwerft. Op deze manier kunt u de attributen en gedragingen die in een andere klasse zijn gedefinieerd, hergebruiken, uitbreiden of wijzigen.
In C++ wordt de klasse die de leden van een andere klasse erft de afgeleide klasse genoemd en de klasse waarvan de leden worden geërfd de basisklasse. De afgeleide klasse is de gespecialiseerde klasse voor de basisklasse.
Voordeel van C++-overerving
Herbruikbaarheid van code: Nu kunt u de leden van uw bovenliggende klasse opnieuw gebruiken. Het is dus niet nodig om het lid opnieuw te definiëren. Er is dus minder code vereist in de klas.
toetsenbord invoegen
Soorten erfenis
C++ ondersteunt vijf soorten overerving:
- Enkelvoudige erfenis
- Meerdere erfenissen
- Hiërarchische erfenis
- Overerving op meerdere niveaus
- Hybride overerving
Afgeleide klassen
Een afgeleide klasse wordt gedefinieerd als de klasse die is afgeleid van de basisklasse.
publieke versus private Java
De syntaxis van de afgeleide klasse:
|_+_|In het bovenstaande geval heeft de functie van de afgeleide klasse voorrang op de methode van de basisklasse. Daarom zal een aanroep van de functie display() eenvoudigweg de functie aanroepen die in de afgeleide klasse is gedefinieerd. Als we de basisklassefunctie willen aanroepen, kunnen we de klasseresolutie-operator gebruiken.
int main() { B b; b.display(); // Calling the display() function of B class. b.B :: display(); // Calling the display() function defined in B class. } C++ hybride overerving
Hybride overerving is een combinatie van meer dan één type overerving.
Laten we een eenvoudig voorbeeld bekijken:
#include using namespace std; class A { protected: int a; public: void get_a() { std::cout << 'Enter the value of 'a' : ' <>a; } }; class B : public A { protected: int b; public: void get_b() { std::cout << 'Enter the value of 'b' : ' <>b; } }; class C { protected: int c; public: void get_c() { std::cout << 'Enter the value of c is : ' <>c; } }; class D : public B, public C { protected: int d; public: void mul() { get_a(); get_b(); get_c(); std::cout << 'Multiplication of a,b,c is : ' < <a*b*c<< std::endl; } }; int main() { d d; d.mul(); return 0; < pre> <p>Output:</p> <pre> Enter the value of 'a' : 10 Enter the value of 'b' : 20 Enter the value of c is : 30 Multiplication of a,b,c is : 6000 </pre> <h2>C++ Hierarchical Inheritance</h2> <p>Hierarchical inheritance is defined as the process of deriving more than one class from a base class.</p> <img src="//techcodeview.com/img/c-tutorial/62/c-inheritance-7.webp" alt="C++ Inheritance"> <p> <strong>Syntax of Hierarchical inheritance:</strong> </p> <pre> 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. } </pre> <p>Let's see a simple example:</p> <pre> #include using namespace std; class Shape // Declaration of base class. { public: int a; int b; void get_data(int n,int m) { a= n; b = m; } }; class Rectangle : public Shape // inheriting Shape class { public: int rect_area() { int result = a*b; return result; } }; class Triangle : public Shape // inheriting Shape class { public: int triangle_area() { float result = 0.5*a*b; return result; } }; int main() { Rectangle r; Triangle t; int length,breadth,base,height; std::cout << 'Enter the length and breadth of a rectangle: ' <>length>>breadth; r.get_data(length,breadth); int m = r.rect_area(); std::cout << 'Area of the rectangle is : ' <<m<< std::endl; std::cout << \\'enter the base and height of triangle: \\' <>base>>height; t.get_data(base,height); float n = t.triangle_area(); std::cout <<\\'area of the triangle is : \\' << n<<std::endl; return 0; } < pre> <p>Output:</p> <pre> Enter the length and breadth of a rectangle: 23 20 Area of the rectangle is : 460 Enter the base and height of the triangle: 2 5 Area of the triangle is : 5 </pre></\\'area></m<<></pre></a*b*c<<> C++ hiërarchische overerving
Hiërarchische overerving wordt gedefinieerd als het proces waarbij meer dan één klasse uit een basisklasse wordt afgeleid.
Syntaxis van hiërarchische overerving:
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. } Laten we een eenvoudig voorbeeld bekijken:
muiswiel scrollt niet goed
#include using namespace std; class Shape // Declaration of base class. { public: int a; int b; void get_data(int n,int m) { a= n; b = m; } }; class Rectangle : public Shape // inheriting Shape class { public: int rect_area() { int result = a*b; return result; } }; class Triangle : public Shape // inheriting Shape class { public: int triangle_area() { float result = 0.5*a*b; return result; } }; int main() { Rectangle r; Triangle t; int length,breadth,base,height; std::cout << 'Enter the length and breadth of a rectangle: ' <>length>>breadth; r.get_data(length,breadth); int m = r.rect_area(); std::cout << 'Area of the rectangle is : ' <<m<< std::endl; std::cout << \\'enter the base and height of triangle: \\' <>base>>height; t.get_data(base,height); float n = t.triangle_area(); std::cout <<\\'area of the triangle is : \\' << n<<std::endl; return 0; } < pre> <p>Output:</p> <pre> Enter the length and breadth of a rectangle: 23 20 Area of the rectangle is : 460 Enter the base and height of the triangle: 2 5 Area of the triangle is : 5 </pre></\\'area></m<<>