C++ Polymorphismus mit Beispiel

Was ist Polymorphismus in C++?

In C++ bewirkt Polymorphismus, dass sich eine Member-Funktion je nach Objekt, das sie aufruft/aufruft, unterschiedlich verhält. Polymorphismus ist ein griechisches Wort, das bedeutet, viele Formen zu haben. Es tritt auf, wenn Sie eine Hierarchie von Klassen haben, die durch Vererbung verbunden sind.

Angenommen, wir haben die Funktion makeSound(). Wenn eine Katze diese Funktion aufruft, erzeugt sie das Miauen. Wenn eine Kuh die gleiche Funktion aufruft, gibt sie das Mau-Geräusch von sich.

Obwohl wir eine Funktion haben, verhält sie sich unter verschiedenen Umständen unterschiedlich. Die Funktion hat viele Formen; daher haben wir Polymorphismus erreicht.

In diesem C++-Tutorial lernen Sie:

• Was ist Polymorphismus?
• Arten von Polymorphismus
• Polymorphismus bei der Kompilierung
• Funktionsüberladung
• Operator-Überladung
• Laufzeitpolymorphismus
• Funktionsüberschreibung
• Virtuelle C++-Funktion
• Kompilierzeit-Polymorphismus vs. Laufzeitpolymorphismus

Arten von Polymorphismus

C++ unterstützt zwei Arten von Polymorphismus:

• Polymorphismus zur Kompilierzeit und
• Laufzeitpolymorphismus.

Polymorphismus bei der Kompilierung

Sie rufen die überladenen Funktionen auf, indem Sie die Anzahl und den Typ der Argumente abgleichen. Die Informationen sind während der Kompilierzeit vorhanden. Das bedeutet, dass der C++-Compiler zur Kompilierzeit die richtige Funktion auswählt.

Polymorphismus zur Kompilierzeit wird durch Überladen von Funktionen und Operatoren erreicht.

Funktionsüberladung

Funktionsüberladung tritt auf, wenn wir viele Funktionen mit ähnlichen Namen, aber unterschiedlichen Argumenten haben. Die Argumente können sich in Anzahl oder Typ unterscheiden.

Beispiel 1:

#include <iostream> 
using namespace std;

void test(int i) {
	cout << " The int is " << i << endl;
}
void test(double  f) {
	cout << " The float is " << f << endl;
}
void test(char const *ch) {
	cout << " The char* is " << ch << endl;
}

int main() {
	test(5);
	test(5.5);
	test("five");
	return 0;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Fügen Sie die iostream-Header-Datei in unseren Code ein. Wir werden in der Lage sein, seine Funktionen zu nutzen.
2. Fügen Sie den std-Namespace in unseren Code ein. Wir können seine Klassen verwenden, ohne sie aufzurufen.
3. Erstellen Sie eine Funktion namens test, die einen ganzzahligen Parameter i akzeptiert. Das { markiert den Beginn des Hauptteils des Funktionstests.
4. Auszuführende Anweisung, wenn obiger Funktionstest aufgerufen/aufgerufen wird.
5. Ende des Hauptteils des obigen Funktionstests.
6. Erstellen Sie eine Funktion namens test, die einen Float-Parameter f akzeptiert. Das { markiert den Beginn des Hauptteils des Funktionstests.
7. Auszuführende Anweisung, wenn obiger Funktionstest aufgerufen/aufgerufen wird.
8. Ende des Hauptteils des obigen Funktionstests.
9. Erstellen Sie eine Funktion namens test, die einen Zeichenparameter ch akzeptiert. Das { markiert den Beginn des Hauptteils des Funktionstests.
10. Auszuführende Anweisung, wenn obiger Funktionstest aufgerufen/aufgerufen wird.
11. Ende des Hauptteils des obigen Funktionstests.
12. Rufen Sie die Funktion main() auf. Das { markiert den Beginn des Hauptteils der Funktion.
13. Rufen Sie den Funktionstest auf und übergeben Sie ihm 5 als Wert des Arguments. Dies ruft die Testfunktion auf, die ein Integer-Argument akzeptiert, d. h. die erste Testfunktion.
14. Rufen Sie den Funktionstest auf und übergeben Sie ihm 5,5 als Wert des Arguments. Dadurch wird die Testfunktion aufgerufen, die ein Float-Argument akzeptiert, also die zweite Testfunktion.
15. Rufen Sie den Funktionstest auf und übergeben Sie ihm fünf als Wert des Arguments. Dadurch wird die Testfunktion aufgerufen, die ein Zeichenargument akzeptiert, also die dritte Testfunktion.
16. Das Programm muss einen Wert zurückgeben, wenn es erfolgreich ausgeführt wird.
17. Das Ende des Hauptteils der Funktion main().

Wir haben drei Funktionen mit demselben Namen, aber unterschiedlichen Arten von Argumenten. Wir haben Polymorphismus erreicht.

Operator-Überladung

In Operator Overloading definieren wir eine neue Bedeutung für einen C++-Operator. Es ändert auch die Funktionsweise des Operators. Zum Beispiel können wir den Operator + definieren, um zwei Strings zu verketten. Wir kennen ihn als Additionsoperator zum Addieren von Zahlenwerten. Nach unserer Definition werden diese hinzugefügt, wenn sie zwischen Ganzzahlen platziert werden. Wenn es zwischen Strings platziert wird, werden sie verkettet.

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:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Integrieren Sie die iostream-Header-Datei in unser Programm, um dessen Funktionen zu nutzen.
2. Nehmen Sie den std-Namensraum in unser Programm auf, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse namens ComplexNum. Das { markiert den Beginn des Klassenkörpers.
4. Verwenden Sie den privaten Zugriffsmodifikator, um Variablen als privat zu markieren, was bedeutet, dass auf sie nur innerhalb der Klasse zugegriffen werden kann.
5. Definieren Sie zwei Integer-Variablen, real und darüber.
6. Verwenden Sie den öffentlichen Zugriffsmodifikator, um den Konstruktor als öffentlich zu markieren, was bedeutet, dass er sogar von außerhalb der Klasse zugänglich ist.
7. Erstellen Sie den Klassenkonstruktor und initialisieren Sie die Variablen.
8. Initialisieren Sie den Wert der Variablen real.
9. Initialisieren Sie den Wert der Variablen über.
10. Ende des Konstruktorkörpers.
11. Wir müssen die Bedeutung des Operators + überschreiben.
12. Erstellen Sie das Datentyp-Ergebnis vom Typ ComplexNum.
13. Verwenden Sie den Operator + mit komplexen Zahlen. Diese Zeile addiert den Realteil einer Zahl zum Realteil einer anderen Zahl.
14. Verwenden Sie den Operator + mit komplexen Zahlen. Diese Zeile addiert den Imaginärteil einer Zahl zum Imaginärteil einer anderen Zahl.
15. Das Programm gibt bei erfolgreicher Ausführung den Wert der Variable result zurück.
16. Ende der Definition der neuen Bedeutung des Operators +, also Überladen.
17. Rufen Sie die Methode print() auf.
18. Drucken Sie die neue komplexe Zahl nach der Addition auf der Konsole.
19. Ende des Hauptteils der Funktion print().
20. Ende des Hauptteils der Klasse ComplexNum.
21. Rufen Sie die Funktion main() auf.
22. Übergeben Sie die Werte der zu addierenden reellen und komplexen Teile. Der erste Teil von c1 wird zum ersten Teil von c2 hinzugefügt, also 10+3. Der zweite Teil von c1 wird zum zweiten Teil von c hinzugefügt, also 2+7.
23. Führen Sie eine Operation mit dem überladenen Operator + durch und speichern Sie das Ergebnis in der Variablen c3.
24. Den Wert der Variablen c3 auf der Konsole ausgeben.
25. Ende des Hauptteils der Funktion main().

Laufzeitpolymorphismus

Dies geschieht, wenn die Methode eines Objekts während der Laufzeit statt während der Kompilierzeit aufgerufen/aufgerufen wird. Laufzeitpolymorphismus wird durch Überschreiben von Funktionen erreicht. Die aufzurufende/aufzurufende Funktion wird zur Laufzeit festgelegt.

Funktionsüberschreibung

Das Überschreiben von Funktionen tritt auf, wenn einer Funktion der Basisklasse eine neue Definition in einer abgeleiteten Klasse gegeben wird. Zu diesem Zeitpunkt können wir sagen, dass die Basisfunktion überschrieben wurde.

Zum 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:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Importieren Sie die iostream-Header-Datei in unser Programm, um seine Funktionen zu nutzen.
2. Nehmen Sie den std-Namensraum in unser Programm auf, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse namens Mammal. Das { markiert den Beginn des Klassenkörpers.
4. Verwenden Sie den öffentlichen Zugriffsmodifikator, um die Funktion, die wir gerade erstellen, als öffentlich zugänglich festzulegen. Es wird von außerhalb dieser Klasse zugänglich sein.
5. Erstelle eine öffentliche Funktion namens eat. Das { markiert den Beginn des Funktionskörpers.
6. Druckt die Anweisung, die der cout-Funktion hinzugefügt wurde, wenn die Funktion eat() aufgerufen wird.
7. Das Ende des Hauptteils der Funktion eat().
8. Ende des Körpers der Klasse Säugetier.
9. Erstellen Sie eine Klasse namens Cow, die die Klasse Mammal erbt. Cow ist die abgeleitete Klasse, während Mammal die Basisklasse ist. Das { markiert den Beginn dieser Klasse.
10. Verwenden Sie den Modifizierer für öffentlichen Zugriff, um die Funktion, die wir gerade erstellen, als öffentlich zugänglich zu markieren. Es wird von außerhalb dieser Klasse zugänglich sein.
11. Überschreiben Sie die Funktion eat(), die in der Basisklasse definiert wurde. Das { markiert den Beginn des Funktionskörpers.
12. Die Anweisung, die auf der Konsole gedruckt werden soll, wenn diese Funktion aufgerufen wird.
13. Ende des Hauptteils der Funktion eat().
14. Ende des Körpers der Klasse Cow.
15. Rufen Sie die Funktion main() auf. Das { markiert den Beginn des Hauptteils dieser Funktion.
16. Erstellen Sie eine Instanz der Cow-Klasse und geben Sie ihr den Namen c.
17. Rufen Sie die Funktion eat() auf, die in der Klasse Cow definiert ist.
18. Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
19. Ende der Funktion main().

Virtuelle C++-Funktion

Eine virtuelle Funktion ist eine weitere Möglichkeit, Laufzeitpolymorphismus in C++ zu implementieren. Es ist eine spezielle Funktion, die in einer Basisklasse definiert und in der abgeleiteten Klasse neu definiert wird. Um eine virtuelle Funktion zu deklarieren, sollten Sie das Schlüsselwort virtual verwenden. Das Schlüsselwort sollte der Deklaration der Funktion in der Basisklasse vorangestellt werden.

Wenn eine virtuelle Funktionsklasse geerbt wird, definiert die virtuelle Klasse die virtuelle Funktion neu, um sie ihren Bedürfnissen anzupassen. Zum 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:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Schließen Sie die iostream-Header-Datei in den Code ein, um ihre Funktionen zu verwenden.
2. Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse namens ClassA.
4. Verwenden Sie den öffentlichen Zugriffsmodifikator, um ein Klassenmitglied als öffentlich zugänglich zu markieren.
5. Erstellen Sie eine virtuelle Funktion namens show(). Es wird eine öffentliche Veranstaltung sein.
6. Der zu druckende Text, wenn die aufgerufene show() aufgerufen wird. endl ist ein C++-Schlüsselwort, was Endzeile bedeutet. Es bewegt den Mauszeiger in die nächste Zeile.
7. Ende des Körpers der virtuellen Funktion show().
8. Ende des Körpers der Klasse ClassA.
9. Erstellen einer neuen Klasse namens ClassB, die die Klasse ClassA erbt. ClassA wird zur Basisklasse, während ClassB zur abgeleiteten Klasse wird.
10. Verwenden Sie den öffentlichen Zugriffsmodifikator, um ein Klassenmitglied als öffentlich zugänglich zu markieren.
11. Definieren Sie die in der Basisklasse abgeleitete virtuelle Funktion show() neu.
12. Der auf der Konsole auszugebende Text, wenn die in der abgeleiteten Klasse definierte show()-Funktion aufgerufen wird.
13. Ende des Hauptteils der Funktion show().
14. Ende des Hauptteils der abgeleiteten Klasse ClassB.
15. Rufen Sie die Funktion main() auf. Die Programmlogik sollte in ihrem Körper hinzugefügt werden.
16. Erstellen Sie eine Zeigervariable namens a. Es zeigt auf die Klasse namens ClassA.
17. Erstellen Sie eine Instanz der Klasse namens ClassB. Die Instanz erhält den Namen b.
18. Weisen Sie die in der Adresse b gespeicherten Werte der Variablen a zu.
19. Rufen Sie die Funktion show() auf, die in der abgeleiteten Klasse definiert ist. Late Binding wurde implementiert.
20. Ende des Hauptteils der Funktion main().

Polymorphismus zur Kompilierzeit vs. Laufzeitpolymorphismus

Hier sind die Hauptunterschiede zwischen den beiden:

Polymorphismus zur Kompilierzeit Laufzeitpolymorphismus Es wird auch als frühe Bindung oder statischer Polymorphismus bezeichnet. Es wird auch als späte/dynamische Bindung oder dynamischer Polymorphismus bezeichnet. Die Methode wird während der Kompilierzeit aufgerufen/aufgerufen. Die Methode wird während der Laufzeit aufgerufen/aufgerufen. Durch Funktionsüberladung und Operatorüberladung implementiert. Durch Methodenüberschreibung und virtuelle Funktionen implementiert. Viele Methoden haben möglicherweise ähnliche Namen, aber eine unterschiedliche Anzahl oder Art von Argumenten.Beispiel, Methodenüberschreibung. Viele Methoden haben möglicherweise einen ähnlichen Namen und denselben Prototyp. Schnellere Ausführung, da die Methodenerkennung während der Kompilierzeit erfolgt. Langsamere Ausführung, da die Methodenerkennung während der Laufzeit erfolgt wird zur Lösung komplexer Probleme bereitgestellt, da Methoden zur Laufzeit entdeckt werden.

Zusammenfassung:

• Polymorphismus bedeutet, viele Formen zu haben.
• Es tritt auf, wenn es eine Hierarchie von Klassen gibt, die durch Vererbung verbunden sind.
• Mit Polymorphismus kann sich eine Funktion je nach Objekt, das sie aufruft/aufruft, unterschiedlich verhalten.
• Beim Kompilierzeit-Polymorphismus wird die aufzurufende Funktion während der Kompilierzeit festgelegt.
• Beim Laufzeitpolymorphismus wird die aufzurufende Funktion zur Laufzeit festgelegt.
• Der Polymorphismus zur Kompilierzeit wird durch Überladen von Funktionen und Operatoren bestimmt.
• Beim Überladen von Funktionen gibt es viele Funktionen mit ähnlichen Namen, aber unterschiedlichen Argumenten.
• Die Parameter können sich in Anzahl oder Typ unterscheiden.
• Beim Überladen von Operatoren wird eine neue Bedeutung für C++-Operatoren definiert.
• Laufzeitpolymorphismus wird durch Überschreiben von Funktionen erreicht.
• Beim Funktionsüberschreiben gibt eine abgeleitete Klasse einer in der Basisklasse definierten Funktion eine neue Definition.