La parola polimorfismo significa avere molte forme. In parole semplici, possiamo definire il polimorfismo come la capacità di un messaggio di essere visualizzato in più di una forma. Un esempio reale di polimorfismo è una persona che allo stesso tempo può avere caratteristiche diverse. Un uomo è allo stesso tempo padre, marito e dipendente. Quindi la stessa persona mostra comportamenti diversi in situazioni diverse. Questo si chiama polimorfismo. Il polimorfismo è considerato una delle caratteristiche importanti della programmazione orientata agli oggetti.
Tipi di polimorfismo
- Polimorfismo in fase di compilazione
- Polimorfismo di runtime
Tipi di polimorfismo
1. Polimorfismo in fase di compilazione
Questo tipo di polimorfismo si ottiene mediante sovraccarico della funzione o sovraccarico dell'operatore.
A. Sovraccarico di funzioni
Quando sono presenti più funzioni con lo stesso nome ma parametri diversi, si dice che le funzioni siano sovraccarico, quindi questo è noto come sovraccarico della funzione. Le funzioni possono essere sovraccaricate da modificando il numero di argomenti o/e cambiando il tipo di argomenti . In termini semplici, è una caratteristica della programmazione orientata agli oggetti che fornisce molte funzioni che hanno lo stesso nome ma parametri distinti quando numerose attività sono elencate sotto un unico nome di funzione. Esistono alcune regole di sovraccarico delle funzioni che dovrebbero essere seguite durante l'overload di una funzione.
Di seguito è riportato il programma C++ per mostrare l'overload delle funzioni o il polimorfismo in fase di compilazione:
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 sul linguaggio di programmazione Java
>Produzione
value of x is 7 value of x is 9.132 value of x and y is 85, 64>
Spiegazione: Nell'esempio precedente, una singola funzione denominata function funzione() agisce diversamente in tre diverse situazioni, che è una proprietà del polimorfismo. Per saperne di più puoi fare riferimento all’articolo – Sovraccarico di funzioni in C++ .
B. Sovraccarico dell'operatore
Il C++ ha la capacità di fornire agli operatori un significato speciale per un tipo di dati, questa capacità è nota come sovraccarico degli operatori. Ad esempio, possiamo utilizzare l'operatore di addizione (+) per la classe string per concatenare due stringhe. Sappiamo che il compito di questo operatore è sommare due operandi. Quindi un singolo operatore '+', quando inserito tra operandi interi, li aggiunge e quando inserito tra operandi stringa, li concatena.
Di seguito è riportato il programma C++ per dimostrare l'overload degli operatori:
CPP
ordina l'arraylist in 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();> }> |
>
>Produzione
12 + i9>
Spiegazione: Nell'esempio precedente, l'operatore '+' è sovraccaricato. Di solito questo operatore viene utilizzato per sommare due numeri (interi o numeri in virgola mobile), ma qui l'operatore viene utilizzato per eseguire la somma di due numeri immaginari o complessi. Per saperne di più su questo, fare riferimento all’articolo – Sovraccarico degli operatori .
2. Polimorfismo di runtime
Questo tipo di polimorfismo è ottenuto da Funzione prioritaria . Il polimorfismo tardivo e il polimorfismo dinamico sono altri nomi per il polimorfismo di runtime. La chiamata di funzione viene risolta in fase di esecuzione in polimorfismo di esecuzione . Al contrario, con il polimorfismo in fase di compilazione, il compilatore determina quale chiamata di funzione associare all'oggetto dopo averlo dedotto in fase di esecuzione.
A. Funzione prioritaria
Funzione prioritaria si verifica quando una classe derivata ha una definizione per una delle funzioni membro della classe base. Si dice che la funzione di base venga sovrascritta.
Funzione prioritaria Spiegazione
Polimorfismo di runtime con membri dati
Il polimorfismo di runtime non può essere ottenuto dai membri dati in C++. Vediamo un esempio in cui accediamo al campo tramite la variabile di riferimento della classe genitore che si riferisce all'istanza della classe derivata.
C++
algoritmo di Kruskals
// 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;> }> |
>
>Produzione
Black>
Possiamo vedere che il riferimento alla classe genitore si riferirà sempre al membro dati della classe genitore.
B. Funzione virtuale
UN funzione virtuale è una funzione membro dichiarata nella classe base utilizzando la parola chiave virtual e ridefinita (sostituita) nella classe derivata.
Alcuni punti chiave sulle funzioni virtuali:
- Le funzioni virtuali sono di natura dinamica.
- Si definiscono inserendo la parola chiave virtuale all'interno di una classe base e sono sempre dichiarati con una classe base e sovrascritti in una classe figlia
- Durante il runtime viene richiamata una funzione virtuale
Di seguito è riportato il programma C++ per dimostrare la funzione virtuale:
C++
Java comparabile
// 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->stampa();> }> |
>
>Produzione
Called virtual Base Class function Called GFG_Base print function>
Esempio 2:
C++
algoritmo di Kruskal
// 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->stampa();> >// Non-virtual function, binded> >// at compile time> >bptr->mostra();> >return> 0;> }> |
>
>Produzione
print derived class show base class>