La paraula polimorfisme significa tenir moltes formes. En paraules simples, podem definir el polimorfisme com la capacitat que té un missatge de mostrar-se en més d'una forma. Un exemple real de polimorfisme és una persona que alhora pot tenir diferents característiques. Un home al mateix temps és un pare, un marit i un empleat. Així, una mateixa persona presenta un comportament diferent en diferents situacions. Això s'anomena polimorfisme. El polimorfisme es considera una de les característiques importants de la programació orientada a objectes.
Tipus de polimorfisme
- Polimorfisme en temps de compilació
- Polimorfisme en temps d'execució
Tipus de polimorfisme
1. Polimorfisme en temps de compilació
Aquest tipus de polimorfisme s'aconsegueix per sobrecàrrega de funcions o sobrecàrrega d'operadors.
A. Sobrecàrrega de funcions
Quan hi ha diverses funcions amb el mateix nom però amb paràmetres diferents, es diu que les funcions ho són sobrecarregat, per tant, això es coneix com a sobrecàrrega de funcions. Les funcions es poden sobrecarregar per canviant el nombre d'arguments o/i canviant el tipus d'arguments . En termes senzills, és una característica de la programació orientada a objectes que ofereix moltes funcions que tenen el mateix nom però paràmetres diferents quan s'enumeren nombroses tasques sota un nom de funció. Hi ha certes regles de sobrecàrrega de funcions que s'han de seguir mentre es sobrecarrega una funció.
A continuació es mostra el programa C++ per mostrar la sobrecàrrega de funcions o el polimorfisme en temps de compilació:
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;> }> |
>
bfs vs dfs
>Sortida
value of x is 7 value of x is 9.132 value of x and y is 85, 64>
Explicació: A l'exemple anterior, una única funció anomenada funció funció () actua de manera diferent en tres situacions diferents, que és una propietat del polimorfisme. Per saber-ne més sobre això, podeu consultar l'article: Sobrecàrrega de funcions en C++ .
B. Sobrecàrrega de l'operador
C++ té la capacitat de proporcionar als operadors un significat especial per a un tipus de dades, aquesta capacitat es coneix com a sobrecàrrega d'operadors. Per exemple, podem fer servir l'operador d'addició (+) per a la classe de cadena per concatenar dues cadenes. Sabem que la tasca d'aquest operador és afegir dos operands. Així, un únic operador ‘+’, quan es col·loca entre operands enters, els afegeix i quan es col·loca entre operands de cadena, els concatena.
A continuació es mostra el programa C++ per demostrar la sobrecàrrega de l'operador:
CPP
java privat vs públic
// 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();> }> |
>
>Sortida
12 + i9>
Explicació: A l'exemple anterior, l'operador '+' està sobrecarregat. Normalment, aquest operador s'utilitza per sumar dos nombres (nombres enters o nombres de coma flotant), però aquí l'operador està fet per fer la suma de dos nombres imaginaris o complexos. Per saber més sobre aquest, consulteu l'article: Sobrecàrrega de l'operador .
2. Polimorfisme en temps d'execució
Aquest tipus de polimorfisme s'aconsegueix per Anulació de funcions . L'enllaç tardà i el polimorfisme dinàmic són altres noms per al polimorfisme en temps d'execució. La trucada de funció es resol en temps d'execució a polimorfisme en temps d'execució . En canvi, amb el polimorfisme en temps de compilació, el compilador determina quina trucada de funció s'ha d'enllaçar amb l'objecte després de deduir-lo en temps d'execució.
A. Anulació de funcions
Anulació de funcions es produeix quan una classe derivada té una definició per a una de les funcions membre de la classe base. Es diu que aquesta funció base està anul·lada.
Anul·lació de la funció Explicació
Polimorfisme en temps d'execució amb membres de dades
Els membres de dades en C++ no poden aconseguir el polimorfisme en temps d'execució. Vegem un exemple on estem accedint al camp per variable de referència de la classe pare que fa referència a la instància de la classe derivada.
C++
sistema de fitxers a linux
// 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;> }> |
>
>Sortida
Black>
Podem veure que la referència de la classe pare sempre es referirà al membre de dades de la classe pare.
B. Funció Virtual
A funció virtual és una funció membre que es declara a la classe base utilitzant la paraula clau virtual i que es torna a definir (Sobreescriu) a la classe derivada.
Alguns punts clau sobre les funcions virtuals:
- Les funcions virtuals són de naturalesa dinàmica.
- Es defineixen inserint la paraula clau virtual dins d'una classe base i sempre es declaren amb una classe base i se substitueixen en una classe secundària
- Es crida una funció virtual durant el temps d'execució
A continuació es mostra el programa C++ per demostrar la funció virtual:
C++
mapa rendir
// 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();> }> |
>
>Sortida
Called virtual Base Class function Called GFG_Base print function>
Exemple 2:
C++
llista buida java
// 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->mostrar();> >return> 0;> }> |
>
>Sortida
print derived class show base class>