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, sowie auf ihre eigene Methode bark(). 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();    // Geerbt von Animal
myDog.bark();   // In Dog definiert

Das Schlüsselwort public vor Animal gibt den Vererbungstyp an. Öffentliche Vererbung bedeutet, dass öffentliche Member der Basisklasse in der abgeleiteten Klasse öffentlich bleiben. Dies ist die häufigste Form und bildet eine „ist-ein“-Beziehung ab: Ein Hund ist ein Tier.

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 Folgendes ausgibt: <brand> goes vroom vroom!
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 ccm (Integer)
Erstellen Sie ein Motorcycle-Objekt, setzen Sie dessen geerbte Member (brand und year) sowie dessen eigenes Member engineCC. Erzeugen Sie dann die drei Ausgabezeilen in der richtigen Reihenfolge: Rufen Sie zuerst die geerbte Methode displayInfo() auf, geben Sie dann den Hubraum selbst mit std::cout << "Engine: " << moto.engineCC << "cc" << std::endl; aus und rufen Sie schließlich die Motorrad-spezifische Methode revEngine() auf. Dies demonstriert die Vererbung durch die Verwendung sowohl der geerbten Methode als auch der eigenen Methode der abgeleiteten Klasse.

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.

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 Attribute brand, year und engineCC
    // TODO: Rufe displayInfo() auf, um die geerbten Informationen anzuzeigen
    // TODO: Gib die Motorinformationen im Format aus: Engine: <engineCC>cc
    // TODO: Rufe revEngine() auf, um das motorradspezifische Verhalten zu demonstrieren

    return 0;
}