C++ Virtual Functions meistern: Konzepte, Beispiele und das Override-Schlüsselwort

C++ Virtuelle Funktionen

Dieses Tutorial erklärt C++ virtuelle Funktionen, ihren Zweck und die praktische Anwendung, illustriert mit Code-Beispielen.

Eine virtuelle Funktion ist ein Basisklassen-Mitglied, das wir erwarten, dass abgeleitete Klassen überschreiben. Die Deklaration einer Funktion als virtual stellt sicher, dass die am stärksten abgeleitete Implementierung aufgerufen wird, auch wenn über einen Basisklassen-Zeiger oder eine Referenz zugegriffen wird.

Wenn eine Basisklasse ein nicht-virtuelles Mitglied enthält, wird der Aufruf dieses Members über einen Basisklassen-Zeiger immer die Basis-Version ausführen, unabhängig vom tatsächlichen Objekttyp. Betrachten Sie Folgendes:

class Base { public: void print() { // Basismplementierung } }; class Derived : public Base { public: void print() { // Abgeleitete Implementierung } }; 

Im folgenden Programm zeigt ein Base* auf eine Derived-Instanz, dennoch löst sich print() zur Basis-Version auf:

int main() { Derived derived1; Base* base1 = &derived1; base1->print(); // ruft Base::print() auf return 0; } 

Um polymorphes Verhalten zu erreichen, deklarieren Sie die Funktion in der Basisklasse als virtual:

class Base { public: virtual void print() { // Basismplementierung } }; 

Virtuelle Funktionen sind zentral für C++ Polymorphie. Für einen tieferen Einstieg siehe unseren C++ Polymorphie Leitfaden.

---

Beispiel 1: Grundlegende Verwendung virtueller Funktionen

#include <iostream> using namespace std; class Base { public: virtual void print() { cout << "Basisfunktion" << endl; } }; class Derived : public Base { public: void print() override { cout << "Abgeleitete Funktion" << endl; } }; int main() { Derived derived1; Base* base1 = &derived1; base1->print(); // gibt Abgeleitete Funktion aus return 0; } 

Ausgabe

Abgeleitete Funktion

Da Base::print virtual ist, wird der Aufruf an Derived::print weitergeleitet, selbst über einen Basisklassen-Zeiger.

---

Der C++ Override-Bezeichner

Seit C++11 hilft das override-Schlüsselwort, versehentliches Fehlüberschreiben zu verhindern, indem es den Compiler zwingt zu überprüfen, dass eine Funktion tatsächlich ein virtuelles Basismitglied überschreibt.

Beispiel:

class Base { public: virtual void print() { // Basismplementierung } }; class Derived : public Base { public: void print() override { // Abgeleitete Implementierung } }; 

Wenn Sie die überschreibende Funktion außerhalb der Klasse definieren, verwenden Sie:

class Derived : public Base { public: void print() override; // Deklaration }; void Derived::print() { // Implementierung } 

---

Sichere Verwendung von override

Ohne override führt ein Tippfehler oder eine Signaturinkompatibilität stillschweigend zu einer neuen Funktion statt einer Überschreibung, was zu subtilen Bugs führt. Der Compiler gibt dann einen Fehler aus, was das Problem sofort sichtbar macht. Häufige Fallstricke sind:

• Nicht übereinstimmende Namen: z. B. pint() statt print()
• Verschiedene Rückgabetypen: z. B. Rückgabe von int statt void
• Parameterinkompatibilität: unterschiedliche Parameterlisten
• Fehlendes virtual in der Basis: die Basisfunktion ist gar nicht virtual

---

Praktischer Einsatz virtueller Funktionen

Betrachten Sie eine Animal-Basisklasse mit abgeleiteten Dog und Cat Klassen. Jede Klasse hält ein type-Mitglied, das durch ihren Konstruktor initialisiert wird.

class Animal { private: string type; public: Animal() : type("Animal") {} virtual string getType() const { return type; } }; class Dog : public Animal { private: string type; public: Dog() : type("Dog") {} string getType() const override { return type; } }; class Cat : public Animal { private: string type; public: Cat() : type("Cat") {} string getType() const override { return type; } }; 

Mit getType() als virtual kann ein einzelner Helfer jedes Tier ausgeben:

void print(Animal* ani) { cout << "Tier: " << ani->getType() << endl; } 

Verwendung in main():

int main() { Animal* animal1 = new Animal(); Animal* dog1 = new Dog(); Animal* cat1 = new Cat(); print(animal1); print(dog1); print(cat1); delete animal1; delete dog1; delete cat1; return 0; } 

Ausgabe

Tier: Animal Tier: Dog Tier: Cat

Indem wir getType() virtual machen, vermeiden wir die Duplizierung der print()-Logik in jeder abgeleiteten Klasse und stellen sicher, dass der korrekte type zugegriffen wird.