Polymorphie und virtuelle Funktionen

Polymorphismus (Vielgestaltigkeit) ermöglicht es, Objekte verschiedener abgeleiteter Klassen über einen Zeiger oder eine Referenz auf ihre Basisklasse zu behandeln. Dies stellt sicher, dass zur Laufzeit die richtige Version der jeweiligen Methode ausgeführt wird (Late Binding).

Virtuelle Funktionen: virtual und override

Um Polymorphismus für eine Methode zu aktivieren, müssen wir sie in der Basisklasse mit dem Schlüsselwort virtual deklarieren. In abgeleiteten Klassen verwenden wir den Spezifikator override, um explizit anzugeben, dass wir diese Methode überschreiben.

class Employee {
public:
    virtual void work() {
        std::cout << "Lavoro generico" << std::endl;
    }
    // WICHTIG: Virtueller Destruktor in der Basisklasse zur Vermeidung von Speicherlecks
    virtual ~Employee() = default;
};

class Developer : public Employee {
public:
    void work() override {
        std::cout << "Scrittura codice in C++" << std::endl;
    }
};

Wenn Sie Zeiger auf die Basisklasse verwenden, löst C++ die richtige Methode zur Laufzeit auf:

Employee* emp = new Developer();
emp->work(); // Stampa "Scrittura codice in C++" invece di "Lavoro generico"
delete emp;

Abstrakte Klassen und rein virtuelle Funktionen

Eine rein virtuelle Funktion (pure virtual function) ist eine virtuelle Elementfunktion, die am Ende mit = 0 deklariert wird. Sie stellt einen formalen Vertrag dar: Die Basisklasse stellt keine Implementierung bereit, sondern delegiert diese vollständig an die Unterklassen.

Eine Klasse, die mindestens eine rein virtuelle Funktion enthält, wird als abstrakte Klasse bezeichnet und kann nicht direkt instanziiert werden.

class Instrument {
public:
    virtual void play() = 0; // Virtuale pura
    virtual ~Instrument() = default;
};

class Piano : public Instrument {
public:
    void play() override {
        std::cout << "Suono del pianoforte..." << std::endl;
    }
};

Probier es aus