Polimorfismo in C ++

La parola polymorphismsignifica avere molte forme. In genere, il polimorfismo si verifica quando esiste una gerarchia di classi e sono correlate per ereditarietà.

Il polimorfismo C ++ significa che una chiamata a una funzione membro provocherà l'esecuzione di una funzione diversa a seconda del tipo di oggetto che richiama la funzione.

Considera il seguente esempio in cui una classe base è stata derivata da altre due classi:

#include <iostream> 
using namespace std;
 
class Shape {
   protected:
      int width, height;
      
   public:
      Shape( int a = 0, int b = 0){
         width = a;
         height = b;
      }
      int area() {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};
class Rectangle: public Shape {
   public:
      Rectangle( int a = 0, int b = 0):Shape(a, b) { }
      
      int area () { 
         cout << "Rectangle class area :" <<endl;
         return (width * height); 
      }
};

class Triangle: public Shape {
   public:
      Triangle( int a = 0, int b = 0):Shape(a, b) { }
      
      int area () { 
         cout << "Triangle class area :" <<endl;
         return (width * height / 2); 
      }
};

// Main function for the program
int main() {
   Shape *shape;
   Rectangle rec(10,7);
   Triangle  tri(10,5);

   // store the address of Rectangle
   shape = &rec;
   
   // call rectangle area.
   shape->area();

   // store the address of Triangle
   shape = &tri;
   
   // call triangle area.
   shape->area();
   
   return 0;
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Parent class area :
Parent class area :

Il motivo dell'output errato è che la chiamata della funzione area () viene impostata una volta dal compilatore come versione definita nella classe base. Questo è chiamatostatic resolution della chiamata di funzione, o static linkage- la chiamata alla funzione viene corretta prima che il programma venga eseguito. A volte viene anche chiamatoearly binding perché la funzione area () viene impostata durante la compilazione del programma.

Ma ora, apportiamo una leggera modifica al nostro programma e facciamo precedere la dichiarazione di area () nella classe Shape con la parola chiave virtual in modo che assomigli a questo -

class Shape {
   protected:
      int width, height;
      
   public:
      Shape( int a = 0, int b = 0) {
         width = a;
         height = b;
      }
      virtual int area() {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};

Dopo questa leggera modifica, quando il codice di esempio precedente viene compilato ed eseguito, produce il seguente risultato:

Rectangle class area
Triangle class area

Questa volta, il compilatore esamina il contenuto del puntatore invece del suo tipo. Quindi, poiché gli indirizzi degli oggetti delle classi tri e rec sono memorizzati in * forma, viene chiamata la rispettiva funzione area ().

Come puoi vedere, ciascuna delle classi figlie ha un'implementazione separata per la funzione area (). Questo è comepolymorphismè generalmente utilizzato. Hai classi diverse con una funzione con lo stesso nome e persino gli stessi parametri, ma con implementazioni diverse.

Funzione virtuale

UN virtual funzione è una funzione in una classe base dichiarata utilizzando la parola chiave virtual. Definire in una classe base una funzione virtuale, con un'altra versione in una classe derivata, segnala al compilatore che non vogliamo un collegamento statico per questa funzione.

Quello che vogliamo è la selezione della funzione da chiamare in un dato punto del programma in base al tipo di oggetto per il quale viene chiamata. Questo tipo di operazione è indicato comedynamic linkage, o late binding.

Funzioni virtuali pure

È possibile che tu voglia includere una funzione virtuale in una classe base in modo che possa essere ridefinita in una classe derivata per adattarsi agli oggetti di quella classe, ma non esiste una definizione significativa che potresti dare per la funzione nella classe base .

Possiamo cambiare l'area della funzione virtuale () nella classe base come segue:

class Shape {
   protected:
      int width, height;

   public:
      Shape(int a = 0, int b = 0) {
         width = a;
         height = b;
      }
      
      // pure virtual function
      virtual int area() = 0;
};

Il = 0 dice al compilatore che la funzione non ha corpo e sopra verrà chiamata la funzione virtuale pure virtual function.