Grundlagen der Vererbung

Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy — Lektion 48 von 104.

Vererbung ermöglicht es einer Klasse, die Eigenschaften und Verhaltensweisen einer anderen Klasse zu übernehmen. Die Klasse, von der geerbt wird, wird als Basisklasse (oder Elternklasse) bezeichnet, und die Klasse, die erbt, wird als abgeleitete Klasse (oder Kindklasse) bezeichnet.

Um eine abgeleitete Klasse zu erstellen, verwenden Sie einen Doppelpunkt, gefolgt vom Zugriffsspezifizierer und dem Namen der Basisklasse:

class Animal {
public:
    std::string name;
    
    void eat() {
        std::cout << name << " is eating" << std::endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        std::cout << name << " says woof!" << std::endl;
    }
};

Die Klasse Dog hat nun Zugriff sowohl auf name als auch auf eat() von Animal, zusätzlich zu ihrer eigenen bark()-Methode. Dies ist das Wesen der Vererbung: die Wiederverwendung von vorhandenem Code bei gleichzeitiger Hinzufügung neuer Funktionalität.

Dog myDog;
myDog.name = "Buddy";
myDog.eat();    // Von Animal geerbt
myDog.bark();   // In Dog definiert

Das Schlüsselwort public vor Animal gibt den Vererbungstyp an. Öffentliche Vererbung bedeutet, dass öffentliche Mitglieder der Basisklasse in der abgeleiteten Klasse öffentlich bleiben. Dies ist die am häufigsten verwendete Form und bildet eine „is-a“-Beziehung (ist-ein) ab: Ein Dog ist ein Animal.

Aufgabe

Einfach

Lassen Sie uns eine einfache Fahrzeug-Hierarchie aufbauen, die Vererbung in Aktion demonstriert. Sie werden eine Basisklasse Vehicle und eine abgeleitete Klasse Motorcycle erstellen, die diese um spezialisiertes Verhalten erweitert.

Sie werden Ihren Code über drei Dateien organisieren:

Vehicle.h: Definieren Sie eine Basisklasse Vehicle mit:
- Einem öffentlichen std::string brand Member
- Einem öffentlichen int year Member
- Einer öffentlichen Methode displayInfo(), die die Marke und das Jahr des Fahrzeugs im Format Brand: <brand>, Year: <year> ausgibt
Motorcycle.h: Definieren Sie eine Klasse Motorcycle, die öffentlich von Vehicle erbt. Diese abgeleitete Klasse sollte Folgendes hinzufügen:
- Ein öffentliches int engineCC Member für den Hubraum
- Eine öffentliche Methode revEngine(), die <brand> goes vroom vroom! ausgibt
Die Klasse Motorcycle erbt automatisch brand, year und displayInfo() von Vehicle.
main.cpp: Lesen Sie drei Eingaben ein (jede in einer separaten Zeile):
1. Markenname (String)
2. Jahr (Integer)
3. Hubraum in CC (Integer)
Erstellen Sie ein Motorcycle-Objekt, setzen Sie dessen geerbte Member (brand und year) sowie dessen eigenes engineCC Member. Demonstrieren Sie dann die Vererbung, indem Sie sowohl die geerbte Methode als auch die motorradspezifische Methode aufrufen.

Ausgabeformat:
```
Brand: <brand>, Year: <year>
Engine: <engineCC>cc
<brand> goes vroom vroom!
```

Zum Beispiel mit den Eingaben Harley, 2022 und 1200:

Brand: Harley, Year: 2022
Engine: 1200cc
Harley goes vroom vroom!

Vergessen Sie nicht, Header-Guards in Ihren Header-Dateien einzufügen und #include "Vehicle.h" in Ihrem Motorcycle-Header zu verwenden, um auf die Basisklasse zuzugreifen.

Spickzettel

Vererbung ermöglicht es einer Klasse, Eigenschaften und Verhaltensweisen von einer anderen Klasse zu übernehmen. Die Klasse, von der geerbt wird, ist die Basisklasse (Elternklasse), und die Klasse, die erbt, ist die abgeleitete Klasse (Kindklasse).

Um eine abgeleitete Klasse zu erstellen, verwenden Sie einen Doppelpunkt, gefolgt vom Zugriffsspezifizierer und dem Namen der Basisklasse:

class Animal {
public:
    std::string name;
    
    void eat() {
        std::cout << name << " is eating" << std::endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        std::cout << name << " says woof!" << std::endl;
    }
};

Die abgeleitete Klasse hat Zugriff auf die öffentlichen Member der Basisklasse sowie auf ihre eigenen Member:

Dog myDog;
myDog.name = "Buddy";
myDog.eat();    // Von Animal geerbt
myDog.bark();   // In Dog definiert

Das Schlüsselwort public spezifiziert die öffentliche Vererbung, was bedeutet, dass öffentliche Member der Basisklasse in der abgeleiteten Klasse öffentlich bleiben. Dies modelliert eine „ist-ein“-Beziehung.

Probier es selbst

#include <iostream>
#include <string>
#include "Motorcycle.h"

using namespace std;

int main() {
    string brand;
    int year;
    int engineCC;

    cin >> brand;
    cin >> year;
    cin >> engineCC;

    // TODO: Erstelle ein Motorcycle-Objekt
    // TODO: Setze die Member brand, year und engineCC
    // TODO: Rufe displayInfo() auf, um die geerbten Informationen anzuzeigen
    // TODO: Gib die Motorinformationen im Format Engine: <engineCC>cc aus
    // TODO: Rufe revEngine() auf, um das motorradspezifische Verhalten zu demonstrieren

    return 0;
}