Polymorphismus in C++

Das Wort Polymorphismus bedeutet, viele Formen zu haben. Typischerweise tritt Polymorphismus auf, wenn es eine Klassenhierarchie gibt und sie durch Vererbung in Beziehung stehen.

C++-Polymorphismus bedeutet, dass ein Aufruf einer Mitgliedsfunktion dazu führt, dass eine andere Funktion ausgeführt wird, abhängig vom Typ des Objekts, das die Funktion aufruft.

Betrachten Sie das folgende Beispiel, in dem eine Basisklasse von zwei anderen Klassen abgeleitet wurde −

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

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Parent class area :
Parent class area :

Der Grund für die fehlerhafte Ausgabe liegt darin, dass der Aufruf der Funktion area() vom Compiler einmalig auf die in der Basisklasse definierte Version gesetzt wird. Dies wird als statische Auflösung bezeichnet des Funktionsaufrufs oder statische Verknüpfung - Der Funktionsaufruf wird festgelegt, bevor das Programm ausgeführt wird. Dies wird manchmal auch als Early Binding bezeichnet weil die Funktion area() während der Kompilierung des Programms gesetzt wird.

Aber jetzt nehmen wir eine kleine Änderung in unserem Programm vor und stellen der Deklaration von area() in der Shape-Klasse das Schlüsselwort virtual voran damit es so aussieht −

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

Wenn nach dieser geringfügigen Änderung der vorherige Beispielcode kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Rectangle class area
Triangle class area

Dieses Mal betrachtet der Compiler den Inhalt des Zeigers anstelle seines Typs. Da also Adressen von Objekten der Klassen tri und rec in *shape gespeichert werden, wird die entsprechende Funktion area() aufgerufen.

Wie Sie sehen können, hat jede der untergeordneten Klassen eine separate Implementierung für die Funktion area(). So entsteht Polymorphismus wird allgemein verwendet. Sie haben verschiedene Klassen mit einer Funktion mit demselben Namen und sogar mit denselben Parametern, aber mit unterschiedlichen Implementierungen.

Virtuelle Funktion

Ein virtuelles function ist eine Funktion in einer Basisklasse, die mit dem Schlüsselwort virtual deklariert wird . Das Definieren einer virtuellen Funktion in einer Basisklasse mit einer anderen Version in einer abgeleiteten Klasse signalisiert dem Compiler, dass wir für diese Funktion keine statische Verknüpfung wünschen.

Was wir wollen, ist, dass die Auswahl der Funktion, die an einem bestimmten Punkt im Programm aufgerufen werden soll, auf der Art des Objekts basiert, für das sie aufgerufen wird. Diese Art von Operation wird als dynamische Verknüpfung bezeichnet , oder spätes Binden .

Rein virtuelle Funktionen

Es ist möglich, dass Sie eine virtuelle Funktion in eine Basisklasse aufnehmen möchten, damit sie in einer abgeleiteten Klasse neu definiert werden kann, um sie an die Objekte dieser Klasse anzupassen, aber dass es keine sinnvolle Definition gibt, die Sie für die Funktion in der Basisklasse geben könnten .

Wir können die virtuelle Funktion area() in der Basisklasse wie folgt ändern −

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

Das =0 teilt dem Compiler mit, dass die Funktion keinen Körper hat und obige virtuelle Funktion als reine virtuelle Funktion bezeichnet wird .