C++ Inheritance

In deze tutorial leren we over inheritance in C++ met behulp van voorbeelden.

Inheritance is een van de sleutelfeatures van objectgeoriënteerd programmeren in C++. Het stelt ons in staat om een nieuwe klasse (afgeleide klasse) te creëren vanuit een bestaande klasse (basisklasse).

De afgeleide klasse erft de features van de basisklasse en kan additionele features van zichzelf hebben. Bijvoorbeeld,

 class Animal { // eat() functie // sleep() functie }; class Dog : public Animal { // bark() functie };

Hier is de Dog klasse afgeleid van de Animal klasse. Aangezien Dog afgeleid is van Animal, zijn leden van Animal toegankelijk voor Dog.

Let op het gebruik van het keyword public tijdens het erven van Dog van Animal.

 class Dog : public Animal {...};

We kunnen ook de keywords private en protected gebruiken in plaats van public. We leren later in deze tutorial over de verschillen tussen het gebruik van private, public en protected.

is-a relatie

Inheritance is een is-a relatie. We gebruiken inheritance alleen als een is-a relatie aanwezig is tussen de twee klassen.

Hier zijn enkele voorbeelden:

• Een auto is een voertuig.
• Sinaasappel is een fruit.
• Een chirurg is een dokter.
• Een hond is een dier.

Voorbeeld 1: Simpel voorbeeld van C++ Inheritance

 // C++ programma om inheritance te demonstreren #include <iostream> using namespace std; // basisklasse class Animal { public: void eat() { cout << "Ik kan eten!" << endl; } void sleep() { cout << "Ik kan slapen!" << endl; } }; // afgeleide klasse class Dog : public Animal { public: void bark() { cout << "Ik kan blaffen! Woef woef!!" << endl; } }; int main() { // Maak object van de Dog klasse Dog dog1; // Leden van de basisklasse aanroepen dog1.eat(); dog1.sleep(); // Lid van de afgeleide klasse aanroepen dog1.bark(); return 0; }

Output

 Ik kan eten! Ik kan slapen! Ik kan blaffen! Woef woef!!

Hier kan dog1 (het object van afgeleide klasse Dog) leden van de basisklasse Animal benaderen. Omdat Dog geërfd is van Animal.

 // Leden van de Animal klasse aanroepen dog1.eat(); dog1.sleep();

C++ protected Leden

De access-modifier protected is vooral relevant wanneer het om C++ inheritance gaat.

Net als private leden, zijn protected leden onbereikbaar buiten de klasse. Echter, ze kunnen worden benaderd door afgeleide klassen en friend klassen/functies.

We hebben protected leden nodig als we de data van een klasse willen verbergen, maar toch willen dat die data geërfd wordt door de afgeleide klassen.

Om meer te leren over protected, verwijzen we naar onze C++ Access Modifiers tutorial.

Voorbeeld 2: C++ protected Leden

 // C++ programma om protected leden te demonstreren #include <iostream> #include <string> using namespace std; // basisklasse class Animal { private: string color; protected: string type; public: void eat() { cout << "Ik kan eten!" << endl; } void sleep() { cout << "Ik kan slapen!" << endl; } void setColor(string clr) { color = clr; } string getColor() { return color; } }; // afgeleide klasse class Dog : public Animal { public: void setType(string tp) { type = tp; } void displayInfo(string c) { cout << "Ik ben een " << type << endl; cout << "Mijn kleur is " << c << endl; } void bark() { cout << "Ik kan blaffen! Woef woef!!" << endl; } }; int main() { // Maak object van de Dog klasse Dog dog1; // Leden van de basisklasse aanroepen dog1.eat(); dog1.sleep(); dog1.setColor("zwart"); // Lid van de afgeleide klasse aanroepen dog1.bark(); dog1.setType("zoogdier"); // getColor() van dog1 als argument gebruiken // getColor() retourneert string data dog1.displayInfo(dog1.getColor()); return 0; }

Output

 Ik kan eten! Ik kan slapen! Ik kan blaffen! Woef woef!! Ik ben een zoogdier Mijn kleur is zwart

Hier is de variabele type protected en is dus toegankelijk vanuit de afgeleide klasse Dog. We kunnen dit zien aangezien we type in de Dog klasse geïnitialiseerd hebben met de functie setType().

Aan de andere kant kan de private variabele color niet in Dog geïnitialiseerd worden.

 class Dog : public Animal { public: void setColor(string clr) { // Fout: lid "Animal::color" is onbereikbaar color = clr; } };

Ook, aangezien het protected keyword data verbergt, kunnen we type niet direct benaderen vanuit een object van de Dog of Animal klasse.

 // Fout: lid "Animal::type" is onbereikbaar dog1.type = "zoogdier";

Access Modes in C++ Inheritance

In onze vorige tutorials hebben we geleerd over C++ access specifiers zoals public, private en protected.

Tot nu toe hebben we het public keyword gebruikt om een klasse af te leiden van een eerder bestaande basisklasse. Echter, we kunnen ook de private en protected keywords gebruiken om klassen af te leiden. Bijvoorbeeld,

 class Animal { // code }; class Dog : private Animal { // code };

 class Cat : protected Animal { // code };

De verschillende manieren waarop we klassen kunnen afleiden worden access modes genoemd. Deze access modes hebben het volgende effect:

1. public: Als een afgeleide klasse in public mode gedeclareerd is, dan worden de leden van de basisklasse geërfd door de afgeleide klasse zoals ze zijn.
2. private: In dit geval worden alle leden van de basisklasse private leden in de afgeleide klasse.
3. protected: De public leden van de basisklasse worden protected leden in de afgeleide klasse.

De private leden van de basisklasse zijn altijd private in de afgeleide klasse.

Om meer te leren, bezoek onze C++ public, private, protected inheritance tutorial.

Lidfunctie Overriding in Inheritance

Stel, basisklasse en afgeleide klasse hebben lidfuncties met dezelfde naam en argumenten.

Als we een object van de afgeleide klasse aanmaken en proberen die lidfunctie te benaderen, wordt de lidfunctie in de afgeleide klasse aangeroepen in plaats van die in de basisklasse.

De lidfunctie van de afgeleide klasse overschrijft de lidfunctie van de basisklasse.

Lees meer over Function overriding in C++.

Aanbevolen Lezen: C++ Multiple Inheritance