C ++ Polymorphismus mit Beispiel

Inhaltsverzeichnis:

Anonim

Was ist Polymorphismus in C ++?

In C ++ führt der Polymorphismus dazu, dass sich eine Elementfunktion basierend auf dem 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 den Miau-Ton. Wenn eine Kuh dieselbe Funktion aufruft, liefert sie das Moow-Geräusch.

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 des Polymorphismus
  • Kompilierungszeitpolymorphismus
  • Funktionsüberladung
  • Überlastung des Bedieners
  • Laufzeitpolymorphismus
  • Funktionsüberschreibung
  • Virtuelle C ++ - Funktion
  • Polymorphismus zur Kompilierungszeit Vs. Laufzeitpolymorphismus

Arten des Polymorphismus

C ++ unterstützt zwei Arten von Polymorphismus:

  • Polymorphismus zur Kompilierungszeit und
  • Laufzeitpolymorphismus.

Kompilierungszeitpolymorphismus

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

Der Polymorphismus zur Kompilierungszeit wird durch Funktionsüberladung und Operatorüberladung 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 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 Erläuterung:

  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 Standard-Namespace in unseren Code ein. Wir können seine Klassen verwenden, ohne ihn aufzurufen.
  3. Erstellen Sie eine Funktion mit dem Namen test, die einen ganzzahligen Parameter i verwendet. Das {markiert den Beginn des Funktionstests.
  4. Anweisung, die ausgeführt werden soll, wenn der obige Funktionstest aufgerufen / aufgerufen wird.
  5. Ende des Körpers des obigen Funktionstests.
  6. Erstellen Sie eine Funktion mit dem Namen test, die einen float-Parameter f verwendet. Das {markiert den Beginn des Funktionstests.
  7. Anweisung, die ausgeführt werden soll, wenn der obige Funktionstest aufgerufen / aufgerufen wird.
  8. Ende des Körpers des obigen Funktionstests.
  9. Erstellen Sie eine Funktion namens test, die einen Zeichenparameter ch verwendet. Das {markiert den Beginn des Funktionstests.
  10. Anweisung, die ausgeführt werden soll, wenn der obige Funktionstest aufgerufen / aufgerufen wird.
  11. Ende des Körpers 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 5 als Wert des Arguments. Dies ruft die Testfunktion auf, die ein ganzzahliges Argument akzeptiert, dh die erste Testfunktion.
  14. Rufen Sie den Funktionstest auf und übergeben Sie 5.5 als Wert des Arguments. Dadurch wird die Testfunktion aufgerufen, die ein float-Argument akzeptiert, dh 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, dh die dritte Testfunktion.
  16. Das Programm muss einen Wert zurückgeben, wenn es erfolgreich ausgeführt wird.
  17. Das Ende des Körpers der main () - Funktion.

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

Überlastung des Bedieners

In Operator Overloading definieren wir eine neue Bedeutung für einen C ++ - Operator. Es ändert auch die Funktionsweise des Bedieners. Zum Beispiel können wir den Operator + definieren, um zwei Zeichenfolgen zu verketten. Wir kennen es als Additionsoperator zum Addieren numerischer Werte. Wenn nach unserer Definition zwischen Ganzzahlen gesetzt wird, werden diese hinzugefügt. Wenn es zwischen Zeichenfolgen platziert wird, werden diese verkettet.

Beispiel 2:

#includeusing 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 Erläuterung:

  1. Nehmen Sie die iostream-Header-Datei in unser Programm auf, um ihre Funktionen nutzen zu können.
  2. Nehmen Sie den Standard-Namespace in unser Programm auf, um seine Klassen zu verwenden, ohne ihn aufzurufen.
  3. Erstellen Sie eine Klasse mit dem Namen ComplexNum. Das {markiert den Beginn des Klassenkörpers.
  4. Verwenden Sie den Modifikator für den privaten Zugriff, um Variablen als privat zu markieren. Dies bedeutet, dass nur innerhalb der Klasse auf sie zugegriffen werden kann.
  5. Definieren Sie zwei ganzzahlige Variablen, real und über.
  6. Verwenden Sie den Modifikator public access, um den Konstruktor als public zu markieren. Dies bedeutet, dass auch von außerhalb der Klasse auf ihn zugegriffen werden kann.
  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 Datentypergebnis vom Typ ComplexNum.
  13. Verwenden Sie den Operator + mit komplexen Zahlen. Diese Zeile fügt den Realteil einer Zahl zum Realteil einer anderen Zahl hinzu.
  14. Verwenden Sie den Operator + mit komplexen Zahlen. Diese Zeile fügt den Imaginärteil einer Zahl zum Imaginärteil einer anderen Zahl hinzu.
  15. Das Programm gibt nach erfolgreicher Ausführung den Wert des Variablenergebnisses zurück.
  16. Ende der Definition der neuen Bedeutung des Operators +, dh Überladung.
  17. Rufen Sie die print () -Methode auf.
  18. Drucken Sie die neue komplexe Nummer nach dem Hinzufügen auf der Konsole aus.
  19. Ende der Funktion print ().
  20. Ende des Körpers der ComplexNum-Klasse.
  21. Rufen Sie die Funktion main () auf.
  22. Übergeben Sie die Werte von Real- und komplexen Teilen, die hinzugefügt werden sollen. Der erste Teil von c1 wird zum ersten Teil von c2 hinzugefügt, dh 10 + 3. Der zweite Teil von c1 wird zum zweiten Teil von c hinzugefügt, dh 2 + 7.
  23. Führen Sie eine Operation mit dem Operator overloaded + aus und speichern Sie das Ergebnis in der Variablen c3.
  24. Drucken Sie den Wert der Variablen c3 auf der Konsole.
  25. Ende des Hauptteils der Funktion main ().

Laufzeitpolymorphismus

Dies geschieht, wenn die Methode eines Objekts zur Laufzeit und nicht zur Kompilierungszeit aufgerufen / aufgerufen wird. Laufzeitpolymorphismus wird durch Überschreiben von Funktionen erreicht. Die aufzurufende / aufzurufende Funktion wird zur Laufzeit eingerichtet.

Funktionsüberschreibung

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

Zum Beispiel:

#include 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 Erläuterung:

  1. Importieren Sie die iostream-Header-Datei in unser Programm, um ihre Funktionen zu nutzen.
  2. Nehmen Sie den Standard-Namespace 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 Modifikator für den öffentlichen Zugriff, um die Funktion, die wir erstellen möchten, als öffentlich zugänglich festzulegen. Es wird von außerhalb dieser Klasse zugänglich sein.
  5. Erstellen Sie eine öffentliche Funktion mit dem Namen eat. Das {markiert den Beginn des Funktionskörpers.
  6. Drucken Sie die Anweisung, die der cout-Funktion hinzugefügt wurde, wenn die Funktion eat () aufgerufen wird.
  7. Das Ende des Funktionskörpers essen ().
  8. Ende des Körpers der Klasse Säugetier.
  9. Erstellen Sie eine Klasse namens Cow, die die Mammal-Klasse erbt. Kuh ist die abgeleitete Klasse, während Säugetier die Basisklasse ist. Das {markiert den Beginn dieser Klasse.
  10. Verwenden Sie den Modifikator für den öffentlichen Zugriff, um die Funktion, die wir erstellen möchten, als öffentlich zugänglich zu markieren. Es wird von außerhalb dieser Klasse zugänglich sein.
  11. Überschreiben Sie die in der Basisklasse definierte Funktion eat (). Das {markiert den Beginn des Funktionskörpers.
  12. Die Anweisung, die beim Aufrufen dieser Funktion auf der Konsole gedruckt werden soll.
  13. Ende des Körpers der Funktion essen ().
  14. Ende des Körpers der Klasse Kuh.
  15. Rufen Sie die Funktion main () auf. Das {markiert den Beginn des Körpers dieser Funktion.
  16. Erstellen Sie eine Instanz der Cow-Klasse und geben Sie ihr den Namen c.
  17. Rufen Sie die in der Cow-Klasse definierte Funktion eat () auf.
  18. Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
  19. Ende der main () -Funktion.

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 vor der Deklaration der Funktion in der Basisklasse stehen.

Wenn eine virtuelle Funktionsklasse geerbt wird, definiert die virtuelle Klasse die virtuelle Funktion neu, um sie ihren Anforderungen anzupassen. Zum Beispiel:

#include 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 Erläuterung:

  1. Fügen Sie die iostream-Headerdatei in den Code ein, um ihre Funktionen zu verwenden.
  2. Fügen Sie den Standard-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
  3. Erstellen Sie eine Klasse mit dem Namen ClassA.
  4. Verwenden Sie den Modifikator für den öffentlichen Zugriff, um ein Klassenmitglied als öffentlich zugänglich zu markieren.
  5. Erstellen Sie eine virtuelle Funktion mit dem Namen show (). Es wird eine öffentliche Veranstaltung sein.
  6. Der Text, der gedruckt werden soll, wenn show () aufgerufen wird, wird aufgerufen. Das 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 mit dem Namen ClassB, die die Klasse ClassA erbt. Klasse A wird zur Basisklasse, während Klasse B zur abgeleiteten Klasse wird.
  10. Verwenden Sie den Modifikator für den öffentlichen Zugriff, um ein Klassenmitglied als öffentlich zugänglich zu markieren.
  11. Definieren Sie die in der Basisklasse abgeleitete virtuelle Funktion show () neu.
  12. Der Text, der auf der Konsole gedruckt werden soll, wenn die in der abgeleiteten Klasse definierte Funktion show () aufgerufen wird.
  13. Ende des Körpers der Funktion show ().
  14. Ende des Körpers der abgeleiteten Klasse, Klasse B.
  15. Rufen Sie die Funktion main () auf. Die Programmlogik sollte in ihrem Hauptteil hinzugefügt werden.
  16. Erstellen Sie eine Zeigervariable mit dem Namen a. Es zeigt auf die Klasse ClassA.
  17. Erstellen Sie eine Instanz der Klasse mit dem Namen ClassB. Die Instanz erhält den Namen b.
  18. Weisen Sie die in der Adresse b in der Variablen a gespeicherten Wertes zu.
  19. Rufen Sie die in der abgeleiteten Klasse definierte Funktion show () auf. Die späte Bindung wurde implementiert.
  20. Ende des Körpers der main () - Funktion.

Polymorphismus zur Kompilierungszeit Vs. Laufzeitpolymorphismus

Hier sind die Hauptunterschiede zwischen den beiden:

Polymorphismus zur Kompilierungszeit 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 Kompilierungszeit aufgerufen / aufgerufen Die Methode wird zur Laufzeit aufgerufen / aufgerufen
Implementiert über Funktionsüberladung und Bedienerüberladung Implementiert über Methodenüberschreibung und virtuelle Funktionen
Beispiel: Methodenüberladung. Viele Methoden haben möglicherweise ähnliche Namen, aber unterschiedliche Anzahlen oder Arten von Argumenten Beispiel: Methode überschreiben. Viele Methoden haben möglicherweise einen ähnlichen Namen und denselben Prototyp.
Schnellere Ausführung, da die Methodenerkennung während der Kompilierungszeit erfolgt Langsamere Ausführung, da der Methodenerkenner zur Laufzeit ausgeführt wird.
Es wird weniger Flexibilität bei der Problemlösung geboten, da während der Kompilierungszeit alles bekannt ist. Für die Lösung komplexer Probleme wird viel Flexibilität geboten, 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.
  • Beim Polymorphismus kann sich eine Funktion je nach dem Objekt, das sie aufruft / aufruft, unterschiedlich verhalten.
  • Beim Polymorphismus zur Kompilierungszeit wird die aufzurufende Funktion während der Kompilierungszeit festgelegt.
  • Beim Laufzeitpolymorphismus wird die aufzurufende Funktion zur Laufzeit eingerichtet.
  • Der Polymorphismus zur Kompilierungszeit wird durch Funktionsüberladung und Operatorüberladung bestimmt.
  • Bei der Funktionsüberladung 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 Überschreiben von Funktionen gibt eine abgeleitete Klasse einer in der Basisklasse definierten Funktion eine neue Definition.