• Eine virtuelle C++-Funktion ist eine Mitgliedsfunktion in der Basisklasse, die Sie in einer abgeleiteten Klasse neu definieren. Es wird mit dem Schlüsselwort virtual deklariert.
• Es wird verwendet, um den Compiler anzuweisen, eine dynamische Verknüpfung oder späte Bindung für die Funktion durchzuführen.
• Es besteht die Notwendigkeit, den einzelnen Zeiger zu verwenden, um auf alle Objekte der verschiedenen Klassen zu verweisen. Also erstellen wir den Zeiger auf die Basisklasse, die auf alle abgeleiteten Objekte verweist. Wenn der Basisklassenzeiger jedoch die Adresse des abgeleiteten Klassenobjekts enthält, wird immer die Basisklassenfunktion ausgeführt. Dieses Problem kann nur durch die Verwendung der „virtuellen“ Funktion gelöst werden.
• Ein „virtual“ ist ein Schlüsselwort, das der normalen Deklaration einer Funktion vorangeht.
• Wenn die Funktion virtuell gemacht wird, bestimmt C++ basierend auf dem Typ des Objekts, auf das der Basisklassenzeiger zeigt, welche Funktion zur Laufzeit aufgerufen werden soll.

Späte Bindung oder dynamische Verknüpfung

Bei später Bindung wird der Funktionsaufruf zur Laufzeit aufgelöst. Daher bestimmt der Compiler zur Laufzeit den Objekttyp und bindet dann den Funktionsaufruf.

Regeln der virtuellen Funktion

Wie viele MB sind in einem GB?

• Virtuelle Funktionen müssen Mitglieder einer Klasse sein.
• Virtuelle Funktionen können keine statischen Mitglieder sein.
• Der Zugriff erfolgt über Objektzeiger.
• Sie können ein Freund einer anderen Klasse sein.
• Eine virtuelle Funktion muss in der Basisklasse definiert sein, auch wenn sie nicht verwendet wird.
• Die Prototypen einer virtuellen Funktion der Basisklasse und aller abgeleiteten Klassen müssen identisch sein. Wenn die beiden Funktionen denselben Namen, aber unterschiedliche Prototypen haben, betrachtet C++ sie als überladene Funktionen.
• Wir können keinen virtuellen Konstruktor haben, aber wir können einen virtuellen Destruktor haben
• Stellen Sie sich die Situation vor, in der wir das Schlüsselwort virtual nicht verwenden.

 #include using namespace std; class A { int x=5; public: void display() { std::cout &lt;&lt; &apos;Value of x is : &apos; &lt;&lt; x&lt;<std::endl; } }; class b: public a { int y="10;" public: void display() std::cout << 'value of is : ' <<y<<std::endl; main() *a; b b; a->display(); return 0; } </std::endl;>

Ausgabe:

 Value of x is : 5 

Im obigen Beispiel ist * a der Basisklassenzeiger. Der Zeiger kann nur auf die Mitglieder der Basisklasse zugreifen, nicht jedoch auf die Mitglieder der abgeleiteten Klasse. Obwohl C++ zulässt, dass der Basiszeiger auf jedes von der Basisklasse abgeleitete Objekt zeigt, kann es nicht direkt auf die Mitglieder der abgeleiteten Klasse zugreifen. Daher besteht Bedarf an einer virtuellen Funktion, die es dem Basiszeiger ermöglicht, auf die Mitglieder der abgeleiteten Klasse zuzugreifen.

Beispiel für eine virtuelle C++-Funktion

Sehen wir uns das einfache Beispiel einer virtuellen C++-Funktion an, die zum Aufrufen der abgeleiteten Klasse in einem Programm verwendet wird.

 #include { public: virtual void display() { cout &lt;&lt; &apos;Base class is invoked&apos;&lt;<endl; } }; class b:public a { public: void display() cout << 'derived is invoked'<<endl; int main() a* a; pointer of base b b; object derived a->display(); //Late Binding occurs } </endl;>

Ausgabe:

 Derived Class is invoked 

Rein virtuelle Funktion

• Eine virtuelle Funktion wird nicht zum Ausführen irgendeiner Aufgabe verwendet. Es dient lediglich als Platzhalter.
• Wenn die Funktion keine Definition hat, wird diese Funktion als „ nichts tun ' Funktion.
• Der ' nichts tun Die Funktion wird als a bezeichnet rein virtuelle Funktion . Eine rein virtuelle Funktion ist eine in der Basisklasse deklarierte Funktion, die keine Definition relativ zur Basisklasse hat.
• Eine Klasse, die die rein virtuelle Funktion enthält, kann nicht zur Deklaration eigener Objekte verwendet werden; solche Klassen werden als abstrakte Basisklassen bezeichnet.
• Das Hauptziel der Basisklasse besteht darin, den abgeleiteten Klassen die Merkmale bereitzustellen und den Basiszeiger zu erstellen, der zum Erreichen des Laufzeitpolymorphismus verwendet wird.

Eine reine virtuelle Funktion kann definiert werden als:

 virtual void display() = 0; 

Sehen wir uns ein einfaches Beispiel an:

Konvertieren Sie einen String in int

 #include using namespace std; class Base { public: virtual void show() = 0; }; class Derived : public Base { public: void show() { std::cout &lt;&lt; &apos;Derived class is derived from the base class.&apos; <show(); return 0; } < pre> <p> <strong>Output:</strong> </p> <pre> Derived class is derived from the base class. </pre> <p>In the above example, the base class contains the pure virtual function. Therefore, the base class is an abstract base class. We cannot create the object of the base class.</p></show();>

Im obigen Beispiel enthält die Basisklasse die rein virtuelle Funktion. Daher ist die Basisklasse eine abstrakte Basisklasse. Wir können das Objekt der Basisklasse nicht erstellen.