Eine virtuelle Funktion in C ++ ist eine Mitgliedsfunktion innerhalb der Basisklasse, die wir in einer abgeleiteten Klasse neu definieren. Dieser Artikel hilft Ihnen dabei, das Konzept im Detail zu untersuchen. Die folgenden Hinweise werden in diesem Artikel behandelt:
- Was ist eine virtuelle Funktion?
- Regeln für die virtuelle Funktion in C ++
- Was ist Bindung?
- Frühe Bindung
- Späte Bindung
- Reine virtuelle Funktion
- Abstrakte Klasse
- Beispiel für eine virtuelle Funktion
Beginnen wir also mit diesem Artikel über virtuelle Funktionen in C ++
Was ist eine virtuelle Funktion?
Eine virtuelle Funktion ist eine Elementfunktion innerhalb der Basisklasse, die wir in einer abgeleiteten Klasse neu definieren. Es wird mit dem virtuellen Schlüsselwort deklariert. Wenn eine Klasse mit einer virtuellen Funktion vererbt wird, definiert die abgeleitete Klasse die virtuelle Funktion neu, um sie ihren eigenen Anforderungen anzupassen.
Fahren Sie mit diesem Artikel über virtuelle Funktionen in C ++ fort
Regeln für die virtuelle Funktion in C ++:
- Sie werden immer in einer Basisklasse definiert und in einer abgeleiteten Klasse überschrieben, es ist jedoch nicht zwingend erforderlich, sie in der abgeleiteten Klasse zu überschreiben.
- Die virtuellen Funktionen müssen im öffentlichen Bereich der Klasse deklariert werden.
- Sie können nicht statisch sein oder die Freundfunktion kann auch nicht die virtuelle Funktion einer anderen Klasse sein.
- Auf die virtuellen Funktionen sollte mit einem Zeiger zugegriffen werden, um einen Laufzeitpolymorphismus zu erzielen.
Fahren Sie mit diesem Artikel über virtuelle Funktionen in C ++ fort.
Was ist verbindlich?
Das Binden von Funktionen bedeutet, dass der Compiler überall dort, wo es einen Funktionsaufruf gibt, wissen muss, mit welcher Funktionsdefinition er übereinstimmen soll. Dies hängt von der Signatur jeder Funktionsdeklaration und den vorgenommenen Zuweisungen ab. Außerdem muss der Compiler wissen, dass dieser Abgleich zwischen dem Funktionsaufruf und der Auswahl der richtigen Definition stattfinden wird.
Fahren Sie mit diesem Artikel über virtuelle Funktionen in C ++ fort
beste Java-Idee für Windows
Frühe Bindung
Frühe Bindung ist ein Phänomen, bei dem die Entscheidung, verschiedene Funktionsaufrufe abzugleichen, zur Kompilierungszeit selbst erfolgt und der Compiler die Verknüpfung direkt mit Adressen verknüpft. Es wird auch als statische Bindung oder Bindung zur Kompilierungszeit bezeichnet.
- Wie wir wissen, schreiben wir Code in der Hochsprache
- Dann konvertiert der Compiler dies in eine einfache Sprache, die der Computer verstehen kann, meistens Maschinensprache zum Zeitpunkt der Kompilierung
- Bei der frühen Bindung stellt der Compiler dem Funktionsaufrufbefehl direkt die Adresse des Funktionsdeklarationsbefehls zur Verfügung
- Wie der Name schon sagt, erfolgt die Bindung sehr früh, bevor das Programm ausgeführt wird.
Beispiel
#include using namespace std class Animals {public: void sound () {cout<< 'Genric animal sound' << endl } } class Cats: public Animals { public: void sound() { cout << 'Cat meow' <sound () // frühe Bindung return 0} Ausgabe
Klarstellungen Ion
In diesem Beispiel haben wir einen Zeiger a auf die übergeordnete Klasse Animals erstellt. Dann begann der Zeiger 'a' durch Schreiben von a = & c auf das Objekt c der Klasse Cats zu verweisen.
a -> sound () - Beim Aufrufen der Funktion sound (), die in beiden Klassen vorhanden ist, durch den Zeiger 'a' wurde die Funktion der übergeordneten Klasse aufgerufen, auch wenn sich der Zeiger auf das Objekt der Klasse Cats bezieht .
Dies ist auf die frühe Bindung zurückzuführen. Wir wissen, dass 'a' ein Zeiger der übergeordneten Klasse ist, der sich auf das Objekt der untergeordneten Klasse bezieht. Da die frühe Bindung zur Kompilierungszeit stattfindet, hat der Compiler, als er sah, dass 'a' ein Zeiger der übergeordneten Klasse ist, den Aufruf mit der Funktion 'sound ()' der übergeordneten Klasse abgeglichen, ohne nach dem Objekt des Zeigers zu suchen bezieht sich auf.
Fahren Sie mit diesem Artikel über virtuelle Funktionen in C ++ fort
Späte Bindung
Bei der späten Bindung identifiziert der Compiler das Objekt zur Laufzeit und ordnet dann den Funktionsaufruf der richtigen Funktion zu. Es wird auch als dynamische Bindung oder Laufzeitbindung bezeichnet.
Eine späte Bindung im obigen Problem kann durch Verwendung eines virtuellen Schlüsselworts in der Basisklasse gelöst werden. Lassen Sie uns anhand des obigen Beispiels sehen, wie dies geschieht, aber nur ein virtuelles Schlüsselwort hinzufügen.
Beispiel
#include using namespace std class Tiere {public: virtual void sound () {cout<< 'Genric aniaml sound' << endl } } class Cats: public Animals { public: void sound() { cout << 'Cats meow' <sound () gibt 0 zurück} Ausgabe
Erläuterung
Hier wird die Funktion sound () der Basisklasse virtuell gemacht, sodass der Compiler jetzt eine späte Bindung für diese Funktion durchführt. Jetzt wird der Funktionsaufruf der Funktion sound () zur Laufzeit an die Funktionsdefinition angepasst. Da der Compiler jetzt den Zeiger 'a' als Verweis auf das Objekt 'c' der abgeleiteten Klasse Cats identifiziert, ruft er die sound () - Funktion der Klasse Cats auf.
Fahren Sie mit diesem Artikel über virtuelle Funktionen in C ++ fort
Reine virtuelle Funktion
Eine reine virtuelle Funktion in C ++ ist eine virtuelle Funktion, für die wir keine Implementierung haben, sondern nur deklarieren. Eine rein virtuelle Funktion wird deklariert, indem in der Deklaration 0 zugewiesen wird.
Virtual Void Sound () = 0
Hier ist sound () eine reine virtuelle Funktion.
Fahren Sie mit diesem Artikel über virtuelle Funktionen in C ++ fort
Abstrakte Klasse
Eine abstrakte Klasse ist definiert als eine Klasse mit einer oder mehreren reinen virtuellen Funktionen. Wie oben erläutert, ist die reine virtuelle Funktion eine virtuelle Elementfunktion, die als nicht implementiert markiert ist. Mit den in der Klasse bereitgestellten Informationen, einschließlich der Basisklassen, ist keine Implementierung möglich. Eine abstrakte Klasse wird auch als abstrakte Basisklasse bezeichnet.
Beispiel
#include using namespace std class Employee // abstrakte Basisklasse {virtual int getSalary () = 0 // reine virtuelle Funktion} class Employee_1: public Employee {int Gehalt public: Employee_1 (int s) {Gehalt = s} int getSalary () {Gehalt zurückgeben}} Klasse Mitarbeiter_2: öffentlich Mitarbeiter {int Gehalt öffentlich: Mitarbeiter_2 (int t) {Gehalt = t} int getSalary () {Gehalt zurückgeben}} int main () {Mitarbeiter_1 e1 (5000) Mitarbeiter_2 e2 (3000) int a, ba = e1.getSalary () b = e2.getSalary () cout<< 'Salary of Developer : ' << a << endl cout << 'Salary of Driver : ' << b << endl return 0 } Ausgabe
Erläuterung
Die Funktion 'getSalary ()' in der Klasse Employee ist eine rein virtuelle Funktion. Da die Employee-Klasse die reine virtuelle Funktion enthält, handelt es sich um eine abstrakte Basisklasse.
Da die reine virtuelle Funktion in den Unterklassen definiert ist, ist die Funktion 'getSalary ()' sowohl in den Unterklassen der Klasse Employee definiert, d. H. In Employee_1 und Employee_2.
Fahren Sie mit diesem Artikel über virtuelle Funktionen in C ++ fort
Beispiel für eine virtuelle Funktion
#include using namespace std class base {public: void function_1 () {cout<< 'base class function 1n' } virtual void function_2() { cout << 'base class function 2n' } virtual void function_3() { cout << 'base class function 3n' } virtual void function_4() { cout << 'base class function 4n' } } class derived : public base { public: void function_1() { cout << 'derived class function 1n' } void function_2() { cout << 'derived class function 2n' } void function_4(int x) { cout function_2 () ptr-> function_3 () ptr-> function_4 ()} Ausgabe
Erläuterung
Für den Funktionsaufruf function_1 () wird die Basisklassenversion der Funktion aufgerufen, function_2 () wird in der abgeleiteten Klasse überschrieben, sodass die abgeleitete Klassenversion aufgerufen wird, function_3 () wird in der abgeleiteten Klasse nicht überschrieben und ist eine virtuelle Funktion, sodass die Basisklassenversion aufgerufen wird. In ähnlicher Weise wird function_4 () nicht überschrieben, sodass die Basisklassenversion aufgerufen wird.
Damit sind wir am Ende dieses Artikels über 'Virtuelle Funktion in C ++' angelangt. Wenn Sie mehr erfahren möchten, lesen Sie die von Edureka, einem vertrauenswürdigen Online-Lernunternehmen. Der Java J2EE- und SOA-Schulungs- und Zertifizierungskurs von Edureka wurde entwickelt, um Sie für Kern- und fortgeschrittene Java-Konzepte sowie für verschiedene Java-Frameworks wie Hibernate & Spring zu schulen.
Hast du eine Frage an uns? Bitte erwähne es im Kommentarbereich dieses Blogs und wir werden uns so schnell wie möglich bei dir melden.