Cuvântul polimorfism înseamnă a avea mai multe forme. Cu cuvinte simple, putem defini polimorfismul ca fiind capacitatea unui mesaj de a fi afișat în mai multe forme. Un exemplu real de polimorfism este o persoană care, în același timp, poate avea caracteristici diferite. Un bărbat este în același timp un tată, un soț și un angajat. Deci aceeași persoană prezintă un comportament diferit în situații diferite. Acest lucru se numește polimorfism. Polimorfismul este considerat una dintre caracteristicile importante ale programării orientate pe obiecte.
Tipuri de polimorfism
- Polimorfism în timp de compilare
- Polimorfismul de rulare
Tipuri de polimorfism
1. Polimorfism în timp de compilare
Acest tip de polimorfism se realizează prin supraîncărcare de funcții sau supraîncărcare a operatorului.
A. Supraîncărcarea funcției
Când există mai multe funcții cu același nume, dar parametri diferiți, atunci se spune că funcțiile sunt supraîncărcat, prin urmare, aceasta este cunoscută sub numele de supraîncărcare a funcției. Funcțiile pot fi supraîncărcate de modificarea numărului de argumente sau și schimbarea tipului de argumente . În termeni simpli, este o caracteristică a programării orientate pe obiecte care oferă multe funcții care au același nume, dar parametri diferiți atunci când numeroase sarcini sunt listate sub un nume de funcție. Există anumite reguli de supraîncărcare a funcției care ar trebui urmate în timpul supraîncărcării unei funcții.
Mai jos este programul C++ pentru a arăta supraîncărcarea funcțiilor sau polimorfismul în timp de compilare:
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;> }> |
>
Arborele binar de traversare a comenzii prin corespondență
>Ieșire
value of x is 7 value of x is 9.132 value of x and y is 85, 64>
Explicaţie: În exemplul de mai sus, o singură funcție numită funcție func() acționează diferit în trei situații diferite, ceea ce este o proprietate a polimorfismului. Pentru a afla mai multe despre acest lucru, puteți consulta articolul - Supraîncărcarea funcției în C++ .
B. Supraîncărcarea operatorului
C++ are capacitatea de a oferi operatorilor o semnificație specială pentru un tip de date, această capacitate fiind cunoscută sub numele de supraîncărcare a operatorului. De exemplu, putem folosi operatorul de adăugare (+) pentru clasa șir pentru a concatena două șiruri. Știm că sarcina acestui operator este să adauge doi operanzi. Deci, un singur operator „+”, atunci când este plasat între operanzi întregi, îi adaugă și atunci când este plasat între operanzi șir, îi concatenează.
Mai jos este programul C++ pentru a demonstra supraîncărcarea operatorului:
CPP
tipărirea declarației în java
// 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();> }> |
>
>Ieșire
12 + i9>
Explicaţie: În exemplul de mai sus, operatorul „+” este supraîncărcat. De obicei, acest operator este folosit pentru a adăuga două numere (numere întregi sau numere în virgulă mobilă), dar aici operatorul este făcut să efectueze adăugarea a două numere imaginare sau complexe. Pentru a afla mai multe despre acesta, consultați articolul - Supraîncărcarea operatorului .
2. Polimorfismul Runtime
Acest tip de polimorfism se realizează prin Suprascrierea funcției . Legarea tardivă și polimorfismul dinamic sunt alte nume pentru polimorfismul în timp de execuție. Apelul funcției este rezolvat în timpul execuției în polimorfismul de rulare . În contrast, cu polimorfismul în timp de compilare, compilatorul determină ce apel de funcție se leagă de obiect după deducerea acestuia în timpul execuției.
A. Suprascrierea funcției
Suprascrierea funcției apare atunci când o clasă derivată are o definiție pentru una dintre funcțiile membre ale clasei de bază. Se spune că această funcție de bază este suprascrisă.
Funcție de suprascriere Explicație
Polimorfism de rulare cu membri de date
Polimorfismul runtime nu poate fi realizat de membrii datelor în C++. Să vedem un exemplu în care accesăm câmpul prin variabila de referință a clasei părinte care se referă la instanța clasei derivate.
C++
comanda Linux Run
// 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;> }> |
>
>Ieșire
Black>
Putem vedea că referința clasei părinte se va referi întotdeauna la membrul de date al clasei părinte.
B. Funcția virtuală
A functie virtuala este o funcție membru care este declarată în clasa de bază folosind cuvântul cheie virtual și este redefinită (Overridden) în clasa derivată.
logica de ordinul întâi
Câteva puncte cheie despre funcțiile virtuale:
- Funcțiile virtuale sunt de natură dinamică.
- Ele sunt definite prin inserarea cuvântului cheie virtual în interiorul unei clase de bază și sunt întotdeauna declarate cu o clasă de bază și suprascrise într-o clasă copil
- O funcție virtuală este apelată în timpul Runtime
Mai jos este programul C++ pentru a demonstra funcția virtuală:
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();> }> |
>
>Ieșire
Called virtual Base Class function Called GFG_Base print function>
Exemplul 2:
C++
program de încapsulare
// 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->arată();> >return> 0;> }> |
>
>Ieșire
print derived class show base class>