C++ Vererbung meistern: Leistungsstarke Klassen mit wiederverwendbarem Code erstellen

C++ Vererbung

In diesem Tutorial lernen Sie Vererbung in C++ anhand von Beispielen kennen.

Vererbung ist eines der Schlüsselmerkmale der objektorientierten Programmierung in C++. Sie ermöglicht es uns, eine neue Klasse (abgeleitete Klasse) aus einer bestehenden Klasse (Basisklasse) zu erstellen.

Die abgeleitete Klasse erbt die Merkmale von der Basisklasse und kann eigene zusätzliche Merkmale haben. Zum Beispiel:

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

Hier wird die Dog-Klasse von der Animal-Klasse abgeleitet. Da Dog von Animal abgeleitet ist, sind Mitglieder von Animal für Dog zugänglich.

Beachten Sie die Verwendung des Schlüsselworts public beim Ableiten von Dog von Animal.

class Dog : public Animal {...};

Wir können auch die Schlüsselwörter private und protected anstelle von public verwenden. Wir werden später in diesem Tutorial die Unterschiede zwischen der Verwendung von private, public und protected kennenlernen.

---

is-a Beziehung

Vererbung ist eine is-a Beziehung. Wir verwenden Vererbung nur, wenn eine is-a Beziehung zwischen den beiden Klassen besteht.

Hier sind einige Beispiele:

• Ein Auto ist ein Fahrzeug.
• Eine Orange ist eine Frucht.
• Ein Chirurg ist ein Arzt.
• Ein Hund ist ein Tier.

---

Beispiel 1: Einfaches Beispiel für C++ Vererbung

// C++ Programm zur Demonstration der Vererbung #include <iostream> using namespace std; // Basisklasse class Animal { public: void eat() { cout << "Ich kann essen!" << endl; } void sleep() { cout << "Ich kann schlafen!" << endl; } }; // Abgeleitete Klasse class Dog : public Animal { public: void bark() { cout << "Ich kann bellen! Wuff wuff!!" << endl; } }; int main() { // Objekt der Dog-Klasse erstellen Dog dog1; // Mitglieder der Basisklasse aufrufen dog1.eat(); dog1.sleep(); // Mitglied der abgeleiteten Klasse aufrufen dog1.bark(); return 0; }

Ausgabe

Ich kann essen! Ich kann schlafen! Ich kann bellen! Wuff wuff!!

Hier kann dog1 (das Objekt der abgeleiteten Klasse Dog) auf Mitglieder der Basisklasse Animal zugreifen. Das liegt daran, dass Dog von Animal vererbt wird.

// Mitglieder der Animal-Klasse aufrufen dog1.eat(); dog1.sleep();

---

C++ protected Mitglieder

Der Zugriffsmodifizierer protected ist besonders relevant bei C++ Vererbung.

Wie private Mitglieder sind protected Mitglieder von außerhalb der Klasse nicht zugänglich. Sie können jedoch von abgeleiteten Klassen und Friend-Klassen/Funktionen zugegriffen werden.

Wir benötigen protected Mitglieder, wenn wir die Daten einer Klasse verbergen wollen, aber dennoch möchten, dass diese Daten von ihren abgeleiteten Klassen geerbt werden.

Um mehr über protected zu erfahren, besuchen Sie unser C++ Zugriffsmodifizierer Tutorial.

---

Beispiel 2: C++ protected Mitglieder

// C++ Programm zur Demonstration von protected Mitgliedern #include <iostream> #include <string> using namespace std; // Basisklasse class Animal { private: string color; protected: string type; public: void eat() { cout << "Ich kann essen!" << endl; } void sleep() { cout << "Ich kann schlafen!" << endl; } void setColor(string clr) { color = clr; } string getColor() { return color; } }; // Abgeleitete Klasse class Dog : public Animal { public: void setType(string tp) { type = tp; } void displayInfo(string c) { cout << "Ich bin ein " << type << endl; cout << "Meine Farbe ist " << c << endl; } void bark() { cout << "Ich kann bellen! Wuff wuff!!" << endl; } }; int main() { // Objekt der Dog-Klasse erstellen Dog dog1; // Mitglieder der Basisklasse aufrufen dog1.eat(); dog1.sleep(); dog1.setColor("black"); // Mitglied der abgeleiteten Klasse aufrufen dog1.bark(); dog1.setType("mammal"); // getColor() von dog1 als Argument verwenden // getColor() gibt string-Daten zurück dog1.displayInfo(dog1.getColor()); return 0; }

Ausgabe

Ich kann essen! Ich kann schlafen! Ich kann bellen! Wuff wuff!! Ich bin ein mammal Meine Farbe ist black

Hier ist die Variable type protected und somit aus der abgeleiteten Klasse Dog zugänglich. Wir sehen dies, da wir type in der Dog-Klasse mit der Funktion setType() initialisiert haben.

Andererseits kann die private Variable color nicht in Dog initialisiert werden.

class Dog : public Animal { public: void setColor(string clr) { // Fehler: Mitglied "Animal::color" ist unzugänglich color = clr; } };

Außerdem können wir type nicht direkt von einem Objekt der Dog- oder Animal-Klasse aus zugreifen, da das protected-Schlüsselwort die Daten verbirgt.

// Fehler: Mitglied "Animal::type" ist unzugänglich dog1.type = "mammal";

---

Zugriffsmodi in C++ Vererbung

In unseren vorherigen Tutorials haben wir über C++ Zugriffsspezifizierer wie public, private und protected gelernt.

Bisher haben wir das public Schlüsselwort verwendet, um eine Klasse von einer zuvor existierenden Basisklasse abzuleiten. Wir können jedoch auch die Schlüsselwörter private und protected verwenden, um Klassen abzuleiten. Zum Beispiel:

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

class Cat : protected Animal { // code };

Die verschiedenen Arten, wie wir Klassen ableiten können, werden als Zugriffsmodi bezeichnet. Diese Zugriffsmodi haben folgende Auswirkungen:

1. public: Wenn eine abgeleitete Klasse im public Modus deklariert wird, werden die Mitglieder der Basisklasse von der abgeleiteten Klasse genauso geerbt, wie sie sind.
2. private: In diesem Fall werden alle Mitglieder der Basisklasse zu private Mitgliedern in der abgeleiteten Klasse.
3. protected: Die public Mitglieder der Basisklasse werden zu protected Mitgliedern in der abgeleiteten Klasse.

Die private Mitglieder der Basisklasse sind in der abgeleiteten Klasse immer private.

Um mehr zu erfahren, besuchen Sie unser C++ public, private, protected Vererbung Tutorial.

---

Mitgliedsfunktionen-Überschreibung in Vererbung

Angenommen, Basisklasse und abgeleitete Klasse haben Mitgliedsfunktionen mit demselben Namen und denselben Argumenten.

Wenn wir ein Objekt der abgeleiteten Klasse erstellen und versuchen, auf diese Mitgliedsfunktion zuzugreifen, wird die Mitgliedsfunktion in der abgeleiteten Klasse aufgerufen, anstatt der in der Basisklasse.

Die Mitgliedsfunktion der abgeleiteten Klasse überschreibt die Mitgliedsfunktion der Basisklasse.

Mehr über Funktionsüberschreibung in C++ erfahren.

---

Empfohlene Lektüre: C++ Mehrfachvererbung