Virtueller Zerstörer in C ++
Nachdem wir über die OOP, Konstrukteure und Zerstörer gesprochen haben, sprechen wir nun über virtuelle Zerstörer. Die virtuellen Zerstörer zerstören das Objekt, wie der Name angibt. Wir haben eine Basisklasse und eine abgeleitete Klasse, die aus der Basisklasse abgeleitet ist. Beide Klassen haben ihre Konstrukteure und Zerstörer. Virtuelle Zerstörer -Freigeklauf.
Warum verwenden wir den virtuellen Destruktor??
Wenn die Ausführung der Klassenelementfunktionen erfolgt oder die Ausführung der main () -Methode endet, wird der Destruktor automatisch aufgerufen, um den Speicher zu befreien, der während der Objekterstellung zugewiesen wird. Warum verwenden wir nun einen virtuellen Zerstörer?? Wenn die Basisklasse gelöscht wird, die auf die abgeleitete Klasse verweist, wird hier der Zeiger (*) verwendet. Der Basisklassen -Destruktor wird nur während dieses Prozesses aufgerufen. Die abgeleitete Klasse Destructor wird nicht aufgerufen, was zu Themen führt. Einer von ihnen ist ein Problem mit Speicherleckage. Um dieses Problem zu vermeiden und unseren Code sicher zu machen, zerstören wir die Objekte praktisch, um den Speicherplatz zu freisetzen, der während der Erstellung von Objekten zugeteilt wurde.
C ++ grundlegendes Beispiel ohne virtuellen Zerstörer
Lassen Sie uns sehen, wie das Programm ohne einen virtuellen Destruktor mit einem einfachen Programm funktioniert, das den Zeiger löscht.
Code:
#enthaltenVerwenden von Namespace STD;
Klasse parent_class0
öffentlich:
Eltern_Class0 ()
Cout<< "Parent Class Constructor" <
Cout<< "Parent Class Destructor" <
Klasse Child_1: public parent_class0
öffentlich:
Child_1 ()
Cout<< "Child Class Constructor" <
Cout<< "Child Class Destructor" <
int main ()
Parent_class0*pointer = new Child_1 ();
Zeiger löschen;
Rückkehr 0;
Dieser Code erklärt, wie der Code ohne einen virtuellen Zerstörer ausgeführt wird. Erstellen Sie zunächst eine Klasse mit dem Namen "Eltern_Class0", die die Elternklasse sein wird. Erstellen Sie in dieser Klasse einen Konstruktor und Destruktor. Wie wir wissen, werden der Konstruktor und Destruktor genauso genannt wie die Klasse. Der Destruktor ist ähnlich wie der Konstruktor, aber er hat ein Symbol (~), das es vom Konstruktor unterscheidet. Drucken Sie im Konstruktor und Destruktor eine Nachricht mit „Cout<<”. Now, create another class which is “Child_1”. This class is derived from the parent class, “Parent_Class0”. The derived class has its constructor and destructor that contain a message to print on the output screen.
In der main () -Methode erstellen wir eine Instanz der „Eltern_Class0“ und weisen ihm eine abgeleitete Klasse zu. Der entscheidende Punkt, den Sie in diesem Fall erinnern sollten, ist, dass wir einen Zeiger verwenden, um die übergeordnete Klasse abzurufen. Wenn es in die übergeordnete Klasse geht, wird der Konstruktor der Elternklassen ausgeführt. Dann geht es an die Kinderklasse und führt seinen Konstruktor aus. Bevor er den Destruktor der Kinderklasse ausführt, muss er den Destruktor der übergeordneten Klasse ausführen. Der Compiler führt den Zerstörer der übergeordneten Klasse aus und beendet die Klasse, ohne den Destruktor einer Kinderklasse auszuführen. Das ist das Problem; Es befreien die Erinnerung an die Klasse des Kindes nicht. Es repräsentiert den Konstruktor einer übergeordneten Klasse, den Konstruktor einer Kinderklasse und den Destruktor einer übergeordneten Klasse. Das zeigt, dass der Destruktor einer Kinderklasse nicht ausgeführt wird. Nach dieser Ausführung löschen wir den Zeiger in der Funktion main ().
Ausgang:
C ++ - Beispiel mit virtuellem Destruktor
Lassen Sie uns den virtuellen Destruktor mit einem einfachen Code diskutieren, um zu unterscheiden, wie er mit und ohne virtuellen Destruktor funktioniert.
Code:
#enthaltenVerwenden von Namespace STD;
Klasse parent_class0
öffentlich:
Eltern_Class0 ()
Cout<< "Parent Class Constructor" <
Cout<< "Parent Class Destructor" <
Klasse Child_1: public parent_class0
öffentlich:
Child_1 ()
Cout<< "Child Class Constructor" <
Cout<< "Child Class Destructor" <
int main ()
Parent_class0*pointer = new Child_1 ();
Zeiger löschen;
Rückkehr 0;
Das erste Programm erklärte das Problem, mit dem wir ohne einen virtuellen Zerstörer konfrontiert sind. Jetzt löst dieser Code dieses Problem mit einem virtuellen Zerstörer. Kopieren Sie zunächst den ersten Code und fügen Sie einfach ein Schlüsselwort an zwei Stellen in diesem Programm hinzu. Dieses Wort ist "virtuell". Fügen Sie dieses Wort mit dem Destruktor der übergeordneten Klasse "Eltern_Class0" ein. Erwähnen Sie dies in ähnlicher Weise mit dem Destruktor der Kinderklasse, der „Child_1“ ist, das aus der Elternklasse abgeleitet ist. Dieses „virtuelle“ Schlüsselwort ändert sich ein wenig und führt zuerst den Destruktor der Kinderklasse „Child_1“ aus. Dann führt es den Zerstörer der übergeordneten Klasse "Eltern_Class0" aus. Der Rest des Programms arbeitet genauso wie es ohne einen virtuellen Zerstörer arbeitet. Durch das Hinzufügen dieses kleinen Code können wir unseren Speicher vor Leckagen speichern. Jetzt werden vier Nachrichten auf der Konsole angezeigt. Zunächst der Konstruktor einer übergeordneten Klasse, dann der Konstruktor einer Kinderklasse, der Destruktor einer Kinderklasse und der Destruktor einer Elternklasse. Am Ende löschen wir den Zeiger innerhalb der Main () -Methode.
Ausgang:
C ++ Beispiel für reine virtuelle Zerstörer
In diesem Code werden wir über den reinen virtuellen Zerstörer sprechen, wie er funktioniert und wie er sich von einem virtuellen Destruktor unterscheidet.
Code:
#enthaltenKlasse parent_0
öffentlich:
virtual ~ parent_0 () = 0;
;
Eltern_0 :: ~ Eltern_0 ()
std :: Cout<< "Hello I am Pure Destructor. You Called Me!";
Klasse Child_0: public Eltern_0
öffentlich:
~ Child_0 () std :: cout<< "Derived destructor is here\n";
;
int main ()
Parent_0* ptr_0 = new Child_0 ();
PTR_0 löschen;
Rückkehr 0;
Die übergeordnete Klasse "Eltern_0" wird im ersten Schritt des Code erstellt. Erstellen Sie den virtuellen übergeordneten Destruktor und weisen Sie ihn mit 0 zu. Dies setzt den virtuellen Destruktor auf reine virtuelle Destruktorin, was bedeutet, dass die übergeordnete Klasse jetzt abstrakt ist und wir die Instanzen dieser Klasse nicht erstellen können. Definieren Sie außerhalb der übergeordneten Klasse "Eltern_0" die Zerstörer und Std :: Cout. Der erforderliche Text wird durch Verwendung des STD :: Couts angezeigt. Leiten Sie dann eine "child_0" -Klasse aus der übergeordneten Klasse ab und definieren Sie ihren Zerstörer. Drucken Sie im Destruktor eine Nachricht aus. Erstellen Sie in der Funktion main () den Zeiger der übergeordneten Klasse und weisen Sie die untergeordnete Klasse zu.
Der Compiler geht zur übergeordneten Klasse "Eltern_0". Wenn der Zeiger erstellt wird, wird sein Konstruktor automatisch aufgerufen. Dann geht der Compiler in die Kinderklasse, um seinen Konstruktor aufzurufen. Nach der erfolgreichen Ausführung des Konstruktors führt es den Destruktor einer Kinderklasse „Child_0“ aus. Dann führt es den Zerstörer einer übergeordneten Klasse aus. Auf diese Weise können wir einen reinen virtuellen Zerstörer machen. Es wird nicht ermutigt, es zu nutzen, da die übergeordnete Klasse durch die Verwendung dieser Methode abstrakt wird. Die meist verwendete Methodik ist virtueller Destruktor und es ist eine gute Praxis.
Ausgang:
Abschluss
Wir haben etwas über den virtuellen Zerstörer gelernt, der vom Konzept der OOP bis hin zu Konstrukteuren und Zerstörern übergeht. Nachdem wir all diese erläutert hatten, diskutierten wir mit Codierungsbeispielen und reinem virtuellem Destruktor über den virtuellen Zerstörer im Detail. Bevor wir den virtuellen Destruktor erklären, müssen wir über die Konstrukteure, Zerstörer und Vererbung informiert werden. In der Vererbung erben wir die Klassen einer übergeordneten Klasse. Die Kinderklassen können mehr als eine sein, aber die Elternklasse ist nur einer. Virtuelle Zerstörer und reine virtuelle Zerstörer werden in der Vererbung angewendet, um vor dem Speicherleckage zu speichern. Vom grundlegenden Beispiel zum erweiterten Beispiel haben wir alles abgedeckt, was Sie wissen sollten, um die Erinnerung an die abgeleitete Klasse zu verwenden und virtuell zu zerstören.