C++ Polymorphie erklärt: Praxisbeispiele & Kernkonzepte

Was ist Polymorphie in C++?

In C++ bewirkt Polymorphie, dass eine Member‑Funktion sich je nach dem Objekt, das sie aufruft, unterschiedlich verhält. Polymorphie ist ein griechisches Wort für „viele Formen“. Sie tritt auf, wenn Sie eine Hierarchie von Klassen haben, die durch Vererbung miteinander verbunden sind.

Beispiel: Angenommen, wir haben die Funktion makeSound(). Ruft eine Katze diese Funktion auf, ertönt ein Miauen. Ruft eine Kuh sie auf, ertönt ein Muh. Obwohl wir nur eine Funktion haben, verhält sie sich unter unterschiedlichen Umständen verschieden – die Funktion hat viele Formen; somit haben wir Polymorphie erreicht.

In diesem C++‑Tutorial lernen Sie:

• Was Polymorphie ist
• Arten der Polymorphie
• Compile‑Time Polymorphie
• Funktionen‑Overloading
• Operator‑Overloading
• Runtime‑Polymorphie
• Funktionen‑Overriding
• C++ Virtuelle Funktionen
• Compile‑Time vs. Run‑Time Polymorphie

Arten der Polymorphie

C++ unterstützt zwei Polymorphie‑Arten:

• Compile‑Time‑Polymorphie, und
• Runtime‑Polymorphie.

Compile‑Time‑Polymorphie

Sie rufen überladene Funktionen auf, indem Sie Anzahl und Typ der Argumente abgleichen. Diese Informationen liegen zur Compile‑Zeit vor, daher wählt der C++‑Compiler die passende Funktion bereits zur Compile‑Zeit aus.

Compile‑Time‑Polymorphie wird durch Funktionen‑Overloading und Operator‑Overloading erreicht.

Funktionen‑Overloading

Funktionen‑Overloading liegt vor, wenn mehrere Funktionen denselben Namen, aber unterschiedliche Parameter haben. Die Parameter können sich in Anzahl oder Typ unterscheiden.

Beispiel 1:

#include <iostream>
using namespace std;
void test(int i) {
    cout << " Der int ist " << i << endl;
}
void test(double f) {
    cout << " Der float ist " << f << endl;
}
void test(char const *ch) {
    cout << " Der char* ist " << ch << endl;
}
int main() {
    test(5);
    test(5.5);
    test("fünf");
    return 0;
}

Ausgabe:

Screenshot des Codes:

Code‑Erklärung:

1. iostream Header einbinden.
2. std‑Namespace nutzen.
3. Funktion test mit Integer‑Parameter i erstellen.
4. Anweisung, die ausgeführt wird, wenn obige test aufgerufen wird.
5. Ende der ersten test‑Funktion.
6. Zweite test‑Funktion mit Float‑Parameter f.
7. Ausführbare Anweisung für zweite test.
8. Ende der zweiten test.
9. Dritte test‑Funktion mit char const* Parameter.
10. Ausführbare Anweisung für dritte test.
11. Ende der dritten test.
12. main() aufrufen.
13. test(5) aufrufen → erste test (int).
14. test(5.5) aufrufen → zweite test (float).
15. test("fünf") aufrufen → dritte test (char*).
16. Programm gibt bei Erfolg Wert zurück.
17. Ende von main().

Wir haben drei Funktionen mit demselben Namen, aber unterschiedlichen Argumenttypen – Polymorphie erreicht.

Operator‑Overloading

Beim Operator‑Overloading definieren Sie eine neue Bedeutung für einen C++‑Operator. Dies ändert auch die Funktionsweise des Operators. Beispiel: Den +‑Operator so definieren, dass er zwei Strings verkettet. Normalerweise ist er der Additionsoperator für Zahlen. Nach unserer Definition addiert er Integers, verkettet aber Strings.

Beispiel 2:

#include <iostream>
using namespace std;
class ComplexNum {
private:
    int real, over;
public:
    ComplexNum(int rl = 0, int ov = 0) {
        real = rl;
        over = ov;
    }
    ComplexNum operator + (ComplexNum const &obj) {
        ComplexNum result;
        result.real = real + obj.real;
        result.over = over + obj.over;
        return result;
    }
    void print() {
        cout << real << " + i" << over << endl;
    }
};
int main() {
    ComplexNum c1(10, 2), c2(3, 7);
    ComplexNum c3 = c1 + c2;
    c3.print();
}

Ausgabe:

Screenshot des Codes:

Code‑Erklärung:

1. iostream Header einbinden.
2. std‑Namespace nutzen.
3. Klasse ComplexNum erstellen.
4. private für Variablen real, over.
5. public für Konstruktor.
6. Konstruktor initialisiert Variablen.
7. real initialisieren.
8. over initialisieren.
9. Konstruktor‑Ende.
10. + Operator überladen.
11. Ergebnis‑Objekt result vom Typ ComplexNum.
12. Realteile addieren.
13. Imaginärteile addieren.
14. result zurückgeben.
15. Ende der Overloading‑Definition.
16. print() Methode.
17. Neue komplexe Zahl nach Addition ausgeben.
18. Ende von print().
19. Ende der Klasse ComplexNum.
20. main() aufrufen.
21. Werte für Real‑ und Imaginärteil übergeben (10+3, 2+7).
22. Überladenen + anwenden, Ergebnis in c3 speichern.
23. c3 ausgeben.
24. Ende von main().

Runtime‑Polymorphie

Dies geschieht, wenn eine Objekt‑Methode zur Laufzeit (nicht zur Compile‑Zeit) aufgerufen wird. Runtime‑Polymorphie wird durch Funktionen‑Overriding erreicht. Die aufzurufende Funktion wird zur Laufzeit festgelegt.

Funktionen‑Overriding

Funktionen‑Overriding tritt auf, wenn eine Basisklassen‑Funktion in einer abgeleiteten Klasse neu definiert wird. Dann sagen wir, die Basisfunktion wurde überschrieben.

Beispiel:

#include <iostream>
using namespace std;
class Mammal {
public:
    void eat() { cout << "Mammals eat..."; }
};
class Cow : public Mammal {
public:
    void eat() { cout << "Cows eat grass..."; }
};
int main(void) {
    Cow c = Cow();
    c.eat();
    return 0;
}

Ausgabe:

Screenshot des Codes:

Code‑Erklärung:

1. iostream Header einbinden.
2. std‑Namespace nutzen.
3. Klasse Mammal erstellen.
4. public für Funktion eat.
5. Funktion eat definieren.
6. Ausgabe bei Aufruf von eat().
7. Ende von eat().
8. Ende der Klasse Mammal.
9. Klasse Cow ableiten von Mammal.
10. public für überschreibende eat.
11. Basisfunktion eat() überschreiben.
12. Ausgabe bei Aufruf der überschriebenen Funktion.
13. Ende der überschriebenen eat().
14. Ende der Klasse Cow.
15. main() aufrufen.
16. Instanz c von Cow erzeugen.
17. eat() der Cow‑Klasse aufrufen.
18. Programm gibt bei Erfolg Wert zurück.
19. Ende von main().

C++ Virtuelle Funktionen

Eine virtuelle Funktion ist ein weiterer Weg, Laufzeit‑Polymorphie in C++ zu implementieren. Es ist eine spezielle Funktion, die in einer Basisklasse definiert und in der abgeleiteten Klasse neu definiert wird. Zur Deklaration eines virtuellen Funktion verwenden Sie das Schlüsselwort virtual vor der Funktionsdeklaration in der Basisklasse.

Wird eine virtuelle Funktion vererbt, definiert die abgeleitete Klasse die virtuelle Funktion neu, um ihren Bedürfnissen gerecht zu werden. Beispiel:

#include <iostream>
using namespace std;
class ClassA {
public:
    virtual void show() {
        cout << "The show() function in base class invoked..." << endl;
    }
};
class ClassB : public ClassA {
public:
    void show() {
        cout << "The show() function in derived class invoked...";
    }
};
int main() {
    ClassA* a;
    ClassB b;
    a = &b;
    a->show();
}

Ausgabe:

Screenshot des Codes:

Code‑Erklärung:

1. iostream Header einbinden.
2. std‑Namespace nutzen.
3. Klasse ClassA erstellen.
4. public für Member.
5. Virtuelle Funktion show() definieren.
6. Text bei Aufruf von show() in Basisklasse.
7. Ende von show() in Basisklasse.
8. Ende der Klasse ClassA.
9. Klasse ClassB ableiten von ClassA.
10. public für Member.
11. Virtuelle Funktion show() in abgeleiteter Klasse neu definieren.
12. Text bei Aufruf von show() in abgeleiteter Klasse.
13. Ende von show() in abgeleiteter Klasse.
14. Ende der Klasse ClassB.
15. main() aufrufen.
16. Zeiger a auf ClassA.
17. Instanz b von ClassB.
18. Adresse von b in a zuweisen.
19. show() der abgeleiteten Klasse aufrufen – Late Binding realisiert.
20. Ende von main().

Compile‑Time‑Polymorphie vs. Run‑Time‑Polymorphie

Wesentliche Unterschiede:

Compile‑Time‑Polymorphie	Run‑Time‑Polymorphie
Auch Early Binding / Statische Polymorphie genannt	Auch Late / Dynamic Binding / Dynamische Polymorphie genannt
Methode wird zur Compile‑Zeit aufgerufen	Methode wird zur Laufzeit aufgerufen
Umgesetzt via Funktions‑Overloading & Operator‑Overloading	Umgesetzt via Methoden‑Overriding & Virtuelle Funktionen
Beispiel: Methoden‑Overloading – gleiche Namen, unterschiedliche Parameteranzahl/‑typen	Beispiel: Methoden‑Overriding – gleicher Name, gleicher Prototyp
Schnellere Ausführung (Methode zur Compile‑Zeit bekannt)	Langsamere Ausführung (Methode zur Laufzeit ermittelt)
Weniger Flexibilität (alles zur Compile‑Zeit bekannt)	Mehr Flexibilität für komplexe Probleme (Methoden zur Laufzeit entdeckt)

Zusammenfassung:

• Polymorphie bedeutet „viele Formen“.
• Sie tritt auf, wenn eine Klassenhierarchie durch Vererbung verbunden ist.
• Mit Polymorphie kann eine Funktion sich je nach aufrufendem Objekt unterschiedlich verhalten.
• Bei Compile‑Time‑Polymorphie wird die aufzurufende Funktion zur Compile‑Zeit festgelegt.
• Bei Runtime‑Polymorphie wird die aufzurufende Funktion zur Laufzeit festgelegt.
• Compile‑Time‑Polymorphie durch Funktionen‑Overloading und Operator‑Overloading.
• Beim Funktionen‑Overloading gibt es viele Funktionen mit ähnlichem Namen, aber unterschiedlichen Argumenten (Anzahl/Typ).
• Beim Operator‑Overloading wird einem C++‑Operator eine neue Bedeutung gegeben.
• Runtime‑Polymorphie durch Funktionen‑Overriding erreicht.
• Beim Funktionen‑Overriding gibt eine abgeleitete Klasse einer Basisklassen‑Funktion eine neue Definition.