Distruttore virtuale in C ++
Dopo aver parlato di OOP, costruttori e distruttori, ora parliamo di distruttori virtuali. I distruttori virtuali, come specificano il nome, distruggono l'oggetto. Abbiamo una classe di base e una classe derivata che deriva dalla classe base. Entrambe le classi hanno i loro costruttori e distruttori. Virtual Destructor libera la reminiscenza che vengono assegnati attraverso l'oggetto della classe derivata mentre elimina gli oggetti della classe derivata usando un puntatore di classe base con la parola chiave "virtuale".
Perché usiamo il distruttore virtuale?
Quando viene eseguita l'esecuzione delle funzioni del membro della classe o l'esecuzione del metodo principale () sta per terminare, il distruttore viene automaticamente chiamato per liberare la memoria assegnata durante la creazione di oggetti. Ora, perché usiamo un distruttore virtuale? Quando la classe di base viene eliminata che indica la classe derivata, il puntatore (*) viene utilizzato qui. Il distruttore della classe base viene chiamato solo durante questo processo. Il distruttore di classe derivato non si chiama che porta a problemi. Uno di questi è un problema di perdita di memoria. Per evitare questo problema e rendere sicuro il nostro codice, distruggiamo praticamente gli oggetti per liberare lo spazio di memoria che è stato assegnato durante la creazione di oggetti eliminando il distruttore della classe base.
Esempio di base C ++ senza distruttore virtuale
Vediamo come funziona il programma senza un distruttore virtuale con un semplice programma che elimina il puntatore.
Codice:
#includereUtilizzo dello spazio dei nomi std;
Class Parent_Class0
pubblico:
Parent_class0 ()
Cout<< "Parent Class Constructor" <
Cout<< "Parent Class Destructor" <
Class Child_1: Public Parent_Class0
pubblico:
Child_1 ()
Cout<< "Child Class Constructor" <
Cout<< "Child Class Destructor" <
int main ()
Parent_Class0*Pointer = new Child_1 ();
Elimina puntatore;
restituzione 0;
Questo codice spiega come il codice esegue senza un distruttore virtuale. Prima di tutto, crea una classe denominata "parent_class0" che sarà la classe principale. All'interno di questa classe, crea un costruttore e un distruttore. Come sappiamo, il costruttore e il distruttore sono nominati come la classe. Il distruttore è rappresentato in modo simile al costruttore ma ha un simbolo (~) che lo differenzia dal costruttore. All'interno del costruttore e del distruttore, stampare un messaggio usando “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.
Nel metodo principale (), creiamo un'istanza di "parent_class0" e assegniamo una classe derivata. Il punto cruciale da ricordare in questo caso è che utilizziamo un puntatore per recuperare la classe genitore. Quando entra all'interno della classe genitore, esegue il costruttore della classe genitore. Quindi, va alla classe figlio ed esegue il suo costruttore. Prima di eseguire il distruttore della classe figlio, deve eseguire il distruttore della classe genitore. Il compilatore esegue il distruttore della classe genitore e termina la classe senza eseguire il distruttore di una classe figlio. Quello è il problema; non libera il ricordo della classe del bambino. Rappresenta il costruttore di una classe genitore, il costruttore di una classe figlio e il distruttore di una classe genitore. Ciò dimostra che il distruttore di una classe figlio non viene eseguito. Dopo questa esecuzione, eliminiamo il puntatore nella funzione principale ().
Produzione:
Esempio C ++ con virtuale distruttore
Discutiamo il distruttore virtuale con un codice semplice per differenziare il modo in cui funziona e senza un distruttore virtuale.
Codice:
#includereUtilizzo dello spazio dei nomi std;
Class Parent_Class0
pubblico:
Parent_class0 ()
Cout<< "Parent Class Constructor" <
Cout<< "Parent Class Destructor" <
Class Child_1: Public Parent_Class0
pubblico:
Child_1 ()
Cout<< "Child Class Constructor" <
Cout<< "Child Class Destructor" <
int main ()
Parent_Class0*Pointer = new Child_1 ();
Elimina puntatore;
restituzione 0;
Il primo programma ha spiegato il problema che stiamo affrontando senza un distruttore virtuale. Ora, questo codice risolverà questo problema usando un distruttore virtuale. Innanzitutto, copia il primo codice e aggiungi solo una parola chiave in due posti in questo programma. Quella parola è "virtuale". Inserisci questa parola con il distruttore della classe genitore, "parent_class0". Allo stesso modo, menzionalo con il distruttore della classe figlio che è "Child_1" che deriva dalla classe genitore. Questa parola chiave "virtuale" fa un piccolo cambiamento ed esegue prima il distruttore della classe Child "Child_1". Quindi, esegue il distruttore della classe genitore, "parent_class0". Il resto del programma funziona come opera senza un distruttore virtuale. Aggiungendo questo piccolo pezzo di codice, possiamo salvare la nostra memoria dalla perdita. Ora visualizza quattro messaggi sulla console. Innanzitutto, il costruttore di una classe genitore, poi il costruttore di una classe figlio, il distruttore di una classe figlio e il distruttore di una classe genitore. Alla fine, eliminiamo il puntatore all'interno del metodo principale ().
Produzione:
C ++ Esempio di puro distruttore virtuale
In questo codice parleremo del puro distruttore virtuale, di come funziona e di come è diverso da un distruttore virtuale.
Codice:
#includereClass Parent_0
pubblico:
virtual ~ parent_0 () = 0;
;
Parent_0 :: ~ parent_0 ()
std :: cout<< "Hello I am Pure Destructor. You Called Me!";
Class Child_0: Public Parent_0
pubblico:
~ Child_0 () std :: cout<< "Derived destructor is here\n";
;
int main ()
Parent_0* ptr_0 = new child_0 ();
Elimina PTR_0;
restituzione 0;
La classe principale "parent_0" è creata nel primo passaggio del codice. Al suo interno, crea il distruttore del genitore virtuale e assegnalo con 0. Questo imposta il distruttore virtuale su puro distruttore virtuale, il che significa che la classe genitore è ora astratta e non possiamo creare le istanze di questa classe. Al di fuori della classe genitore "parent_0", definiscono i distruttori e la std :: cout. Il testo richiesto viene mostrato utilizzando la std :: cout. Quindi, deriva una classe "Child_0" dalla classe genitore e definisce il suo distruttore. All'interno del distruttore, stampare un messaggio. Nella funzione principale (), crea il puntatore della classe genitore e assegna la classe figlio ad essa.
Il compilatore va alla classe principale "parent_0". Quando viene creato il puntatore, il suo costruttore viene automaticamente chiamato. Quindi, il compilatore entra nella classe figlio per invocare il suo costruttore. Dopo la riuscita esecuzione del costruttore, esegue il distruttore di una classe figlio "Child_0". Quindi, esegue il distruttore di una classe genitore. In questo modo, possiamo creare un puro distruttore virtuale. Non è incoraggiato a utilizzarlo perché impiegando questo metodo, la classe genitore diventa astratta, il che lo rende inutile. La metodologia che viene principalmente utilizzata è il distruttore virtuale ed è una buona pratica.
Produzione:
Conclusione
Abbiamo imparato a conoscere il distruttore virtuale a partire dal concetto di OOP per muoversi verso i costruttori e i distruttori. Dopo aver spiegato tutti questi, abbiamo discusso in dettaglio del distruttore virtuale con esempi di codifica e puro distruttore virtuale. Prima di spiegare il distruttore virtuale, dobbiamo conoscere i costruttori, i distruttori e l'eredità. In eredità, ereditiamo le lezioni di una classe genitore. Le classi di figli possono essere più di una ma la classe genitore è solo una. Distruttori virtuali e puri distruttori virtuali vengono applicati in eredità per salvare dalla perdita di memoria. Dall'esempio di base all'esempio avanzato, abbiamo coperto tutto ciò che dovresti sapere per iniziare a usare e distruggere praticamente la memoria della classe derivata.