Das Wort Polymorphismus bedeutet, viele Formen zu haben. Mit einfachen Worten können wir Polymorphismus als die Fähigkeit einer Nachricht definieren, in mehr als einer Form angezeigt zu werden. Ein reales Beispiel für Polymorphismus ist eine Person, die gleichzeitig unterschiedliche Eigenschaften haben kann. Ein Mann ist gleichzeitig Vater, Ehemann und Angestellter. Dieselbe Person zeigt also in verschiedenen Situationen ein unterschiedliches Verhalten. Dies nennt man Polymorphismus. Polymorphismus gilt als eines der wichtigen Merkmale der objektorientierten Programmierung.
Arten von Polymorphismus
- Polymorphismus zur Kompilierungszeit
- Laufzeitpolymorphismus
Arten von Polymorphismus
1. Polymorphismus zur Kompilierungszeit
Diese Art von Polymorphismus wird durch Funktionsüberladung oder Operatorüberladung erreicht.
A. Funktionsüberladung
Wenn es mehrere Funktionen mit demselben Namen, aber unterschiedlichen Parametern gibt, spricht man von Funktionen überladen, Daher wird dies als Funktionsüberladung bezeichnet. Funktionen können überlastet werden Ändern der Anzahl der Argumente oder und Ändern der Art der Argumente . Einfach ausgedrückt handelt es sich dabei um ein Merkmal der objektorientierten Programmierung, das viele Funktionen mit demselben Namen, aber unterschiedlichen Parametern bereitstellt, wenn zahlreiche Aufgaben unter einem Funktionsnamen aufgeführt sind. Es gibt bestimmte Regeln für das Überladen von Funktionen, die beim Überladen einer Funktion befolgt werden sollten.
Unten ist das C++-Programm zur Darstellung von Funktionsüberladung oder Polymorphismus zur Kompilierungszeit:
C++
// C++ program to demonstrate> // function overloading or> // Compile-time Polymorphism> #include> using> namespace> std;> class> Geeks {> public>:> >// Function with 1 int parameter> >void> func(>int> x)> >{> >cout <<>'value of x is '> << x << endl;> >}> >// Function with same name but> >// 1 double parameter> >void> func(>double> x)> >{> >cout <<>'value of x is '> << x << endl;> >}> >// Function with same name and> >// 2 int parameters> >void> func(>int> x,>int> y)> >{> >cout <<>'value of x and y is '> << x <<>', '> << y> ><< endl;> >}> };> // Driver code> int> main()> {> >Geeks obj1;> >// Function being called depends> >// on the parameters passed> >// func() is called with int value> >obj1.func(7);> >// func() is called with double value> >obj1.func(9.132);> >// func() is called with 2 int values> >obj1.func(85, 64);> >return> 0;> }> |
>
Tutorial zur Java-Programmiersprache
>Ausgabe
value of x is 7 value of x is 9.132 value of x and y is 85, 64>
Erläuterung: Im obigen Beispiel eine einzelne Funktion mit dem Namen function func() verhält sich in drei verschiedenen Situationen unterschiedlich, was eine Eigenschaft des Polymorphismus ist. Um mehr darüber zu erfahren, können Sie den Artikel lesen – Funktionsüberladung in C++ .
B. Überlastung des Bedieners
C++ hat die Fähigkeit, den Operatoren eine besondere Bedeutung für einen Datentyp zu geben; diese Fähigkeit wird als Operatorüberladung bezeichnet. Beispielsweise können wir den Additionsoperator (+) für die Zeichenfolgenklasse verwenden, um zwei Zeichenfolgen zu verketten. Wir wissen, dass die Aufgabe dieses Operators darin besteht, zwei Operanden hinzuzufügen. Ein einzelner Operator „+“ fügt also, wenn er zwischen Integer-Operanden platziert wird, diese hinzu, und wenn er zwischen String-Operanden platziert wird, verkettet er sie.
Nachfolgend finden Sie das C++-Programm zur Veranschaulichung der Operatorüberladung:
CPP
Arraylist in Java-Sortierung
// C++ program to demonstrate> // Operator Overloading or> // Compile-Time Polymorphism> #include> using> namespace> std;> class> Complex {> private>:> >int> real, imag;> public>:> >Complex(>int> r = 0,>int> i = 0)> >{> >real = r;> >imag = i;> >}> >// This is automatically called> >// when '+' is used with between> >// two Complex objects> >Complex operator+(Complex>const>& obj)> >{> >Complex res;> >res.real = real + obj.real;> >res.imag = imag + obj.imag;> >return> res;> >}> >void> print() { cout << real <<>' + i'> << imag << endl; }> };> // Driver code> int> main()> {> >Complex c1(10, 5), c2(2, 4);> >// An example call to 'operator+'> >Complex c3 = c1 + c2;> >c3.print();> }> |
>
>Ausgabe
12 + i9>
Erläuterung: Im obigen Beispiel ist der Operator „+“ überladen. Normalerweise wird dieser Operator zum Addieren zweier Zahlen (Ganzzahlen oder Gleitkommazahlen) verwendet, aber hier dient der Operator dazu, die Addition zweier imaginärer oder komplexer Zahlen durchzuführen. Um mehr darüber zu erfahren, lesen Sie den Artikel – Überlastung des Bedieners .
2. Laufzeitpolymorphismus
Diese Art von Polymorphismus wird erreicht durch Funktionsüberschreibung . Late Binding und Dynamic Polymorphism sind andere Bezeichnungen für Laufzeitpolymorphismus. Der Funktionsaufruf wird zur Laufzeit in aufgelöst Laufzeitpolymorphismus . Im Gegensatz dazu bestimmt der Compiler beim Kompilierzeitpolymorphismus, welcher Funktionsaufruf an das Objekt gebunden werden soll, nachdem er ihn zur Laufzeit abgeleitet hat.
Python __dict__
A. Funktionsüberschreibung
Funktionsüberschreibung Tritt auf, wenn eine abgeleitete Klasse eine Definition für eine der Mitgliedsfunktionen der Basisklasse hat. Diese Basisfunktion soll überschrieben werden.
Erklärung zur Überschreibung der Funktion
Laufzeitpolymorphismus mit Datenelementen
Laufzeitpolymorphismus kann durch Datenelemente in C++ nicht erreicht werden. Sehen wir uns ein Beispiel an, in dem wir über die Referenzvariable der übergeordneten Klasse auf das Feld zugreifen, die auf die Instanz der abgeleiteten Klasse verweist.
C++
// C++ program for function overriding with data members> #include> using> namespace> std;> // base class declaration.> class> Animal {> public>:> >string color =>'Black'>;> };> // inheriting Animal class.> class> Dog :>public> Animal {> public>:> >string color =>'Grey'>;> };> // Driver code> int> main(>void>)> {> >Animal d = Dog();>// accessing the field by reference> >// variable which refers to derived> >cout << d.color;> }> |
>
>Ausgabe
Black>
Wir können sehen, dass sich die Referenz auf die übergeordnete Klasse immer auf das Datenelement der übergeordneten Klasse bezieht.
B. Virtuelle Funktion
A virtuelle Funktion ist eine Mitgliedsfunktion, die in der Basisklasse mit dem Schlüsselwort virtual deklariert und in der abgeleiteten Klasse neu definiert (überschrieben) wird.
Einige wichtige Punkte zu virtuellen Funktionen:
- Virtuelle Funktionen sind dynamischer Natur.
- Sie werden durch Einfügen des Schlüsselworts definiert virtuell innerhalb einer Basisklasse und werden immer mit einer Basisklasse deklariert und in einer untergeordneten Klasse überschrieben
- Zur Laufzeit wird eine virtuelle Funktion aufgerufen
Nachfolgend finden Sie das C++-Programm zur Demonstration der virtuellen Funktion:
C++
Finden Sie in String c++
// C++ Program to demonstrate> // the Virtual Function> #include> using> namespace> std;> // Declaring a Base class> class> GFG_Base {> public>:> >// virtual function> >virtual> void> display()> >{> >cout <<>'Called virtual Base Class function'> ><<>'
'>;> >}> >void> print()> >{> >cout <<>'Called GFG_Base print function'> ><<>'
'>;> >}> };> // Declaring a Child Class> class> GFG_Child :>public> GFG_Base {> public>:> >void> display()> >{> >cout <<>'Called GFG_Child Display Function'> ><<>'
'>;> >}> >void> print()> >{> >cout <<>'Called GFG_Child print Function'> ><<>'
'>;> >}> };> // Driver code> int> main()> {> >// Create a reference of class GFG_Base> >GFG_Base* base;> >GFG_Child child;> >base = &child;> >// This will call the virtual function> >base->GFG_Base::display();> >// this will call the non-virtual function> >base->print();> }> |
>
>
Laden Sie YouTube-Videos mit VLC herunterAusgabe
Called virtual Base Class function Called GFG_Base print function>
Beispiel 2:
C++
// C++ program for virtual function overriding> #include> using> namespace> std;> class> base {> public>:> >virtual> void> print()> >{> >cout <<>'print base class'> << endl;> >}> >void> show() { cout <<>'show base class'> << endl; }> };> class> derived :>public> base {> public>:> >// print () is already virtual function in> >// derived class, we could also declared as> >// virtual void print () explicitly> >void> print() { cout <<>'print derived class'> << endl; }> >void> show() { cout <<>'show derived class'> << endl; }> };> // Driver code> int> main()> {> >base* bptr;> >derived d;> >bptr = &d;> >// Virtual function, binded at> >// runtime (Runtime polymorphism)> >bptr->print();> >// Non-virtual function, binded> >// at compile time> >bptr->show();> >return> 0;> }> |
>
>Ausgabe
print derived class show base class>