Virtuelle Funktionen in C++

1. Virtuelle Funktionen in C++
2. Regeln virtueller Funktionen in C++
3. Reine virtuelle Funktionen in C++ verstehen

Dieser Artikel behandelt virtuelle Funktionen in C++. Virtuelle Funktionen sind spezielle Elementfunktionen, die entweder überladen oder von der abgeleiteten Deklaration überschrieben, aber in einer Basisklasse definiert und deklariert werden.

Virtuelle Funktionen in C++

Das Schlüsselwort virtual wird der Funktionsdeklaration in der Basisklasse vorangestellt. Dadurch führt der Compiler eine späte Bindung durch, die auch als dynamische Verknüpfung für die Funktion bezeichnet wird.

Spätes Binden oder dynamisches Binden am Laufzeitcompiler entscheidet über den Objekttyp und bindet den Funktionsaufruf. Einfach ausgedrückt handelt es sich um eine Art Bindung, bei der der Funktionsaufruf zur Laufzeit aufgelöst wird.

Mit diesen Funktionen wird Laufzeitpolymorphismus erreicht. Wann immer also eine Funktion in C++ virtuell gemacht wird, entscheidet der Compiler zur Laufzeit, welche Funktion er aufrufen muss, basierend auf dem Objekt, auf das der Zeiger der Basisklasse zeigt.

Beispielcode:

#include <bits/stdc++.h>
using namespace std;

class demo {
 public:
  virtual void fun() { cout << "Inside the base class\n"; }

  void check() { cout << "Base class function\n"; }
};

class derived : public demo {
 public:
  void fun() { cout << "Inside the derived class\n"; }

  void check() { cout << "Derived class fuction\n"; }
};

int main() {
  demo *ptr;
  derived d;
  ptr = &d;

  ptr->fun();

  ptr->check();
}

Ausgang:

Inside the derived class
Base class function

Da im obigen Code ptr->fun() eine virtuelle Funktion ist, wird sie zur Laufzeit gebunden, während ptr->check() eine nicht virtuelle Funktion ist, also zur Kompilierzeit gebunden wird. Hier wurde der Laufzeitpolymorphismus unter Verwendung des Basisklassenzeigers erreicht, der auf das Objekt der abgeleiteten Klasse zeigt.

Regeln virtueller Funktionen in C++

Bei der Arbeit mit virtuellen Funktionen müssen wir die folgenden Regeln beachten.

1. Wir können keine virtuellen Konstruktoren haben, aber wir können einen virtuellen Destruktor haben. Die Verwendung virtueller Destruktoren stellt sicher, dass abgeleitete Klassenobjekte in der richtigen Reihenfolge zerstört werden; zuerst wird das Basisklassenobjekt zerstört und dann wird die abgeleitete Klasse zerstört.

   Beispielcode:

   #include <bits/stdc++.h>
   using namespace std;
   
   class demo {
    public:
     demo() { cout << "Constructing base class\n"; }
   
     virtual ~demo() { cout << "Destroying base class\n"; }
   };
   
   class derived : public demo {
    public:
     derived() { cout << "Constructing derived class\n"; }
   
     virtual ~derived() { cout << "Destroying the derived class\n"; }
   };
   
   int main() {
     demo *ptr;
     derived *derivedPtr = new derived();
   
     ptr = derivedPtr;
   
     delete ptr;
   }
   

   Ausgabe: Wir können beobachten, dass die richtige Bau- und Zerstörungsreihenfolge eingehalten wird.

   Constructing base class
   Constructing derived class
   Destroying the derived class
   Destroying base class
   

2. Nur Basisklassenzeiger oder Basisklassenreferenzen sollten mit virtuellen Funktionen verwendet werden, wenn wir Laufzeitpolymorphismus erreichen wollen.
3. Virtuelle Funktionen können niemals statisch sein.
4. Der virtuelle Funktionsprototyp sollte in den Basis- und abgeleiteten Klassen gleich bleiben.
5. Virtuelle Funktionen können auch eine friend-Funktion einer anderen Klasse sein.

Reine virtuelle Funktionen in C++ verstehen

Diese Funktionen sind leichte Variationen der ursprünglichen virtuellen Funktionen. Eine rein virtuelle Funktion ist eine virtuelle Funktion, die nichts tut.

Syntax:

virtual void fun() = 0

Reine virtuelle Funktionen werden verwendet, um abstrakte Klassen zu erstellen. Dies sind Klassen, deren Objekte nicht erstellt werden können, und die davon abgeleiteten Klassen sollten die reine virtuelle Funktion überschreiben; Andernfalls werden sie auch als abstrakte Klasse behandelt.

Beispielcode:

#include <bits/stdc++.h>
using namespace std;

class demo {
 public:
  virtual void fun() = 0;
};

class derived : public demo {
 public:
  void fun()  // overriding the function
  {
    cout << "Inside the derived class";
  }
};

int main() {
  demo *ptr;

  // demo d;  This will give compile error as base class demo is abstract class

  derived d;
  ptr = &d;

  ptr->fun();
}

Ausgang:

Inside the derived class