Beachten Sie die Verwendung des Schlüsselworts public beim Erben von Hund von Tier.

class Dog : public Animal {...};

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

ist-eine Beziehung

Vererbung ist eine ist-eine-Beziehung . Wir verwenden die Vererbung nur bei einer ist-eine-Beziehung zwischen den beiden Klassen vorhanden ist.

Hier sind einige Beispiele:

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

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

// C++ program to demonstrate inheritance

#include <iostream>
using namespace std;

// base class
class Animal {

   public:
    void eat() {
        cout << "I can eat!" << endl;
    }

    void sleep() {
        cout << "I can sleep!" << endl;
    }
};

// derived class
class Dog : public Animal {
 
   public:
    void bark() {
        cout << "I can bark! Woof woof!!" << endl;
    }
};

int main() {
    // Create object of the Dog class
    Dog dog1;

    // Calling members of the base class
    dog1.eat();
    dog1.sleep();

    // Calling member of the derived class
    dog1.bark();

    return 0;
}

Ausgabe

I can eat!
I can sleep!
I can bark! Woof woof!!

Hier, Hund1 (das Objekt der abgeleiteten Klasse Dog ) kann auf Mitglieder der Basisklasse Animal zugreifen . Weil Dog wird von Animal geerbt .

// Calling members of the Animal class
dog1.eat();
dog1.sleep();

C++ geschützte Mitglieder

Der Zugriffsmodifikator protected ist besonders relevant, wenn es um die C++-Vererbung geht.

Wie private Mitglieder, protected Mitglieder sind außerhalb der Klasse nicht zugänglich. Sie können jedoch von abgeleiteten Klassen aufgerufen werden und Freundesklassen/-funktionen .

Wir brauchen protected Mitglieder, wenn wir die Daten einer Klasse verstecken wollen, aber trotzdem wollen, dass diese Daten von ihren abgeleiteten Klassen geerbt werden.

Weitere Informationen zu protected finden Sie in unserem C++-Zugriffsmodifizierer-Tutorial.

Beispiel 2:C++ geschützte Mitglieder

// C++ program to demonstrate protected members

#include <iostream>
#include <string>
using namespace std;

// base class
class Animal {

   private:
    string color;

   protected:
    string type;

   public:
    void eat() {
        cout << "I can eat!" << endl;
    }

    void sleep() {
        cout << "I can sleep!" << endl;
    }

    void setColor(string clr) {
        color = clr;
    }

    string getColor() {
        return color;
    }
};

// derived class
class Dog : public Animal {

   public:
    void setType(string tp) {
        type = tp;
    }

    void displayInfo(string c) {
        cout << "I am a " << type << endl;
        cout << "My color is " << c << endl;
    }

    void bark() {
        cout << "I can bark! Woof woof!!" << endl;
    }
};

int main() {
    // Create object of the Dog class
    Dog dog1;

    // Calling members of the base class
    dog1.eat();
    dog1.sleep();
    dog1.setColor("black");

    // Calling member of the derived class
    dog1.bark();
    dog1.setType("mammal");

    // Using getColor() of dog1 as argument
    // getColor() returns string data
    dog1.displayInfo(dog1.getColor());

    return 0;
}

Ausgabe

I can eat!
I can sleep!
I can bark! Woof woof!!
I am a mammal
My color is black

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

Andererseits der private Variable Farbe kann nicht in Dog initialisiert werden .

class Dog : public Animal {

    public:
      void setColor(string clr) {
          // Error: member "Animal::color" is inaccessible
          color = clr; 
      }
};

Auch seit dem protected Schlüsselwort verbirgt Daten, wir können nicht auf type zugreifen direkt aus einem Objekt von Dog oder Animal Klasse.

// Error: member "Animal::type" is inaccessible
dog1.type = "mammal";

Zugriffsmodi in der C++-Vererbung

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

Bisher haben wir den public verwendet Schlüsselwort, um eine Klasse von einer bereits existierenden Basisklasse zu erben. Wir können aber auch den private verwenden und protected Schlüsselwörter zum Erben von Klassen. Zum Beispiel

class Animal {
    // code
};

class Dog : private Animal {
    // code
};

class Cat : protected Animal {
    // code
};

Die verschiedenen Arten, wie wir Klassen ableiten können, sind als Zugriffsmodi bekannt . Diese Zugriffsarten haben folgende Wirkung:

1. öffentlich: Wenn eine abgeleitete Klasse in public deklariert ist Modus, dann werden die Mitglieder der Basisklasse von der abgeleiteten Klasse so geerbt, wie sie sind.
2. privat: In diesem Fall werden alle Mitglieder der Basisklasse zu private Mitglieder in der abgeleiteten Klasse.
3. geschützt: Der public Mitglieder der Basisklasse werden zu protected Mitglieder in der abgeleiteten Klasse.

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

Um mehr zu erfahren, besuchen Sie unser Tutorial zur öffentlichen, privaten und geschützten Vererbung von C++.

Überschreiben der Mitgliedsfunktion bei der Vererbung

Angenommen, die Basisklasse und die 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 anstelle derjenigen in der Basisklasse aufgerufen.

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

Erfahren Sie mehr über das Überschreiben von Funktionen in C++.

Empfohlene Lektüre: C++-Mehrfachvererbung