Es könnte jedoch ein virtueller Destruktor vorhanden sein. Hier zeigen wir, was passiert, wenn wir in C++ einen virtuellen Konstruktor erstellen, sowie die Funktionsweise des virtuellen Destruktors anstelle des virtuellen Konstruktors.
Beispiel 1:
Erstellen wir den virtuellen Konstruktor und beginnen unseren Code mit der Platzierung der Header-Datei „iostream“. Diese Header-Datei ist für die darin deklarierten Funktionen wie „cin“ und „cout“ vorgesehen. Danach fügen wir den Namespace „std“ hinzu, sodass wir diesen „std“ nicht bei jeder Funktion in unserem Code hinzufügen können. Danach erstellen wir eine Klasse, die die Basisklasse unseres Codes ist, mit dem Namen „my_base“ und fügen dann „public“ hinzu, um den virtuellen Konstruktor zu erstellen.
Der virtuelle Konstruktor wird hier durch Platzieren des Schlüsselworts „virtual“ erstellt. In diesem virtuellen Konstruktor platzieren wir eine „cout“-Anweisung. Darunter erstellen wir eine Funktion namens „show“, in der wir das „cout“ erneut verwenden. Anschließend erstellen wir eine abgeleitete Klasse dieser Basisklasse mit dem Namen „my_derived“ und richten dann den Konstruktor „my_derived()“ im Feld „public“ ein. Wir fügen eine „cout“-Anweisung in diesen „my_derived()“-Konstruktor ein. Darunter erstellen wir eine Funktion namens „show“, in der wir noch einmal den Befehl „cout“ verwenden.
Nachdem wir nun „main()“ aufgerufen haben, erstellen wir einen Zeiger der Basisklasse mit dem Namen „my_ptr“ und erstellen außerdem das Objekt der abgeleiteten Klasse, nämlich „Obj_d“. Danach weisen wir die Adresse von „Obj_d“ dem „my_ptr“ zu. Dann rufen wir die Funktion „show()“ über „my_ptr“ auf.
Code 1:
#include
verwenden Namensraum std ;
Klasse meine_basis
{
öffentlich :
virtuell meine_basis ( )
{
cout << „Hier ist meine Basisklasse“ << endl ;
}
Leere zeigen ( )
{
cout << „Die Show-Funktion der Basisklasse“ << endl ;
}
} ;
Klasse my_derived : öffentlich meine_basis
{
öffentlich :
my_derived ( )
{
cout << „Hier ist meine abgeleitete Klasse“ << endl ;
}
Leere zeigen ( )
{
cout << „die Show-Funktion der abgeleiteten Klasse“ < zeigen ( ) ;
}
Ausgabe:
Hier wird eine Fehlermeldung angezeigt, die besagt, dass der Konstruktor in der C++-Programmierung nicht als virtuell deklariert werden kann. Wir können also sehen, dass C++ es uns nicht erlaubt, den virtuellen Konstruktor zu generieren, aber wir können den virtuellen Destruktor erstellen.
Beispiel 2:
Lassen Sie uns das vorherige Problem lösen und den virtuellen Destruktor in diesem Code erstellen. Nachdem wir die Klasse „new_base“ deklariert haben, platzieren wir den „public“-Konstruktor, in dem wir den virtuellen Destruktor erstellen, indem wir „virtual ~“ mit „new_base“ hinzufügen. Wir fügen eine „cout“-Anweisung in diesen virtuellen Destruktor ein. Darunter konstruieren wir eine Funktion namens „show“, die den „cout“ nutzt. Als nächstes erstellen wir eine abgeleitete Klasse, die „new_derived“ dieser „new_base“-Basisklasse ist, und erstellen den „new_derived()“-Destruktor im „public“-Feld. Diesem „new_derived()“-Destruktor wurde jetzt eine „cout“-Anweisung hinzugefügt.
Darunter erstellen wir eine Funktion namens „show“, die erneut die „cout“-Anweisung verwendet. Nach dem Aufruf der Funktion „main()“ erzeugen wir nun ein Objekt der abgeleiteten Klasse „obj_d“ sowie einen Zeiger der Basisklasse namens „ptr1“. Anschließend geben wir die „obj_d“-Adresse an „ptr1“ weiter. Als nächstes wird die Methode „show()“ mit „ptr1“ aufgerufen.
Code 2:
#includeverwenden Namensraum std ;
Klasse neue_Basis
{
öffentlich :
virtuell ~new_base ( )
{
cout << „Der Basisklassen-Destruktor ist da“ << endl ;
}
Leere zeigen ( )
{
cout << „Die Show-Funktion der Basisklasse“ << endl ;
}
} ;
Klasse new_derived : öffentlich neue_Basis
{
öffentlich :
~new_derived ( )
{
cout << „Der abgeleitete Klassendestruktor ist da“ << endl ;
}
Leere zeigen ( )
{
cout << „Die Show-Funktion der Basisklasse“ < zeigen ( ) ;
}
Ausgabe:
Dieses Programm verwendet ein Zeigerobjekt der „new_base“, das auf die abgeleitete Klasse „obj_d“ zeigt. Daher ruft es zuerst die Methode „show()“ der Klasse „new_base“ auf. Anschließend ruft es die Methode „~new_derived()“ der Klasse „new_derived“ auf und zeigt die „~new_base“ der Basisklasse an.
Beispiel 3:
Hier ist ein weiterer Code zum Generieren des „virtuellen“ Konstruktors. Nachdem wir den Namensraum „iostream“ und „std“ eingebunden haben, generieren wir eine Klasse „B“. Darunter erstellen wir den „öffentlichen“ Konstruktor „B()“ und generieren dann den „cout“. Die Konstruktor- und Destruktorfunktionen werden durch die Verwendung eines „öffentlichen“ Zugriffsspezifizierers definiert, den jedes Objekt in der Klasse aufrufen kann.
Jetzt erstellen wir auch den „~B()“-Destruktor dieser Basisklasse, in dem wir den „cout“ erneut verwenden. Dann erstellen wir die Klasse „D“, die die abgeleitete Klasse der Basisklasse „B“ ist, und platzieren „öffentlich“ hier. Innerhalb dieser „Öffentlichkeit“ erstellen wir den Konstruktor sowie den Destruktor der abgeleiteten Klasse mit den Namen „D()“ bzw. „~D“. Beide enthalten das „cout“ in sich. Jetzt haben wir die Funktion „main()“. Nach dem Aufruf dieser Funktion generieren wir das Zeigerobjekt der Basisklasse.
Dann verwenden wir das Schlüsselwort „delete“ und platzieren „base_ptr“ hier. In diesem Fall wird der Speicherplatz des Destruktors durch den Aufruf des Zeigerobjekts der Basisklasse gelöscht.
Code 3:
#includeverwenden Namensraum std ;
Klasse B
{
öffentlich :
B ( )
{
cout << „Konstruktor der Basisklasse“ << endl ;
}
~B ( )
{
cout << „Destruktor der Basisklasse“ << endl ;
}
} ;
Klasse D : öffentlich B
{
öffentlich :
D ( )
{
cout << „Konstruktor der Derived-Klasse“ << endl ;
}
~D ( )
{
cout << „Destruktor der abgeleiteten Klasse“ << endl ;
}
} ;
int hauptsächlich ( )
{
B * base_ptr = neu D ;
löschen base_ptr ;
}
Ausgabe:
Das Ergebnis zeigt, dass ein Zeigerobjekt verwendet wird, das auf die Klasse „B“ in der Hauptfunktion zeigt. Daher ruft es zuerst den „constructor()“ der Klasse „B“ auf. Anschließend wird der „constructor()“ der Klasse „D“ aufgerufen. Anschließend wird das Zeigerobjekt gelöscht, das von den Destruktoren der Klassen „B“ und „D“ gehalten wird. Ohne den Destruktor der Klasse „D“ innerhalb des Programms aufzurufen, eliminiert der Klassenzeiger „B“ nur den Destruktor der Klasse „B“. Infolgedessen ist der Speicher des Programms beschädigt.
Abschluss
Wir haben das Konzept der „virtuellen Konstruktion“ in der C++-Programmierung besprochen. Wir haben untersucht, dass wir den virtuellen Konstruktor in C++ nicht erstellen können, aber wir können den virtuellen Destruktor in unseren Codes erstellen. Hier haben wir gezeigt, was passiert, wenn wir den virtuellen Konstruktor in der C++-Programmierung erstellen und wie der virtuelle Destruktor in unseren Codes funktioniert. Wir haben gelernt, dass der Konstruktor nicht virtuell sein kann, aber wir können den virtuellen Destruktor in unserer Klasse generieren. In diesem Handbuch haben wir einige Beispiele gezeigt und diese Codes ausführlich erklärt.