Polymorfisme in C++

Het woord polymorfisme betekent vele vormen hebben. Meestal treedt polymorfisme op wanneer er een hiërarchie van klassen is en deze verwant zijn door overerving.

C++ polymorfisme betekent dat een aanroep van een lidfunctie ervoor zorgt dat een andere functie wordt uitgevoerd, afhankelijk van het type object dat de functie aanroept.

Beschouw het volgende voorbeeld waar een basisklasse is afgeleid door andere twee klassen −

#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;
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Parent class area :
Parent class area :

De reden voor de onjuiste uitvoer is dat de aanroep van de functie area() eenmaal door de compiler wordt ingesteld als de versie die is gedefinieerd in de basisklasse. Dit heet statische resolutie van de functieaanroep, of statische koppeling - de functieaanroep staat vast voordat het programma wordt uitgevoerd. Dit wordt ook wel vroege binding genoemd omdat de functie area() is ingesteld tijdens de compilatie van het programma.

Maar laten we nu een kleine wijziging aanbrengen in ons programma en de declaratie van area() in de klasse Shape voorafgaan met het trefwoord virtual zodat het er zo uitziet −

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;
      }
};

Na deze kleine wijziging, wanneer de vorige voorbeeldcode wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Rectangle class area
Triangle class area

Deze keer kijkt de compiler naar de inhoud van de aanwijzer in plaats van naar het type. Vandaar dat, aangezien adressen van objecten van tri- en rec-klassen worden opgeslagen in *shape, de respectieve area()-functie wordt aangeroepen.

Zoals u kunt zien, heeft elk van de onderliggende klassen een afzonderlijke implementatie voor het functiegebied (). Dit is hoe polymorfisme algemeen wordt gebruikt. Je hebt verschillende klassen met een functie met dezelfde naam, en zelfs dezelfde parameters, maar met verschillende implementaties.

Virtuele functie

Een virtuele functie is een functie in een basisklasse die wordt gedeclareerd met het sleutelwoord virtual . Het definiëren in een basisklasse van een virtuele functie, met een andere versie in een afgeleide klasse, geeft aan de compiler aan dat we geen statische koppeling willen voor deze functie.

Wat we wel willen, is dat de selectie van de functie die op een bepaald punt in het programma moet worden aangeroepen, is gebaseerd op het soort object waarvoor deze wordt aangeroepen. Dit soort bewerking wordt dynamische koppeling genoemd , of late binding .

Puur virtuele functies

Het is mogelijk dat u een virtuele functie in een basisklasse wilt opnemen zodat deze opnieuw kan worden gedefinieerd in een afgeleide klasse om te passen bij de objecten van die klasse, maar dat er geen zinvolle definitie is die u zou kunnen geven voor de functie in de basisklasse .

We kunnen het virtuele functiegebied() in de basisklasse veranderen in het volgende −

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;
};

De =0 vertelt de compiler dat de functie geen body heeft en dat de bovenliggende virtuele functie pure virtuele functie wordt genoemd .