Després de parlar de l'OOP, els constructors i els destructors, ara parlem dels destructors virtuals. Els destructors virtuals, com el seu nom indica, destrueixen l'objecte. Tenim una classe base i una classe derivada que es deriva de la classe base. Ambdues classes tenen els seus constructors i destructors. El destructor virtual allibera reminiscències que s'assignen a través de l'objecte de classe derivada mentre esborra els objectes de la classe derivada mitjançant un punter de classe base amb la paraula clau 'virtual'.
Per què utilitzem el destructor virtual?
Quan s'acaba l'execució de les funcions dels membres de la classe o l'execució del mètode main() està a punt d'acabar, es crida automàticament al destructor per alliberar la memòria que s'assigna durant la creació de l'objecte. Ara, per què fem servir un destructor virtual? Quan s'elimina la classe base que apunta a la classe derivada, aquí s'utilitza el punter (*). El destructor de classe base només es crida durant aquest procés. El destructor de classes derivats no s'anomena, cosa que genera problemes. Un d'ells és un problema de fuga de memòria. Per evitar aquest problema i fer que el nostre codi sigui segur, destruïm pràcticament els objectes per alliberar l'espai de memòria que es va assignar durant la creació d'objectes suprimint el destructor de classe base.
Exemple bàsic de C++ sense destructor virtual
Vegem com funciona el programa sense un destructor virtual amb un programa senzill que elimina el punter.
Codi:
#inclouutilitzant l'espai de noms std ;
classe Parent_Class0
{
públic :
Parent_Class0 ( )
{ cout << 'Constructor de classes pares' << endl ; }
~Parent_Class0 ( )
{ cout << 'Destructor de la classe dels pares' << endl ; }
} ;
classe Child_1 : públic Parent_Class0
{
públic :
Nen_1 ( )
{ cout << 'Constructor de classe infantil' << endl ; }
~Nil_1 ( )
{ cout << 'Destructor de classe infantil' << endl ; }
} ;
int principal ( )
{
Parent_Class0 * punter = nou Child_1 ( ) ;
esborra el punter ;
tornar 0 ;
}
Aquest codi explica com s'executa el codi sense un destructor virtual. En primer lloc, creeu una classe anomenada 'Parent_Class0' que serà la classe pare. Dins d'aquesta classe, creeu un constructor i un destructor. Com sabem, el constructor i el destructor s'anomenen igual que la classe. El destructor es representa de manera semblant al constructor però té un símbol (~) que el diferencia del constructor. Dins del constructor i del destructor, imprimiu un missatge amb 'cout<<'. Ara, creeu una altra classe que sigui 'Child_1'. Aquesta classe es deriva de la classe pare, 'Parent_Class0'. La classe derivada té el seu constructor i destructor que contenen un missatge per imprimir a la pantalla de sortida.
En el mètode main(), creem una instància de 'Parent_Class0' i li assignem una classe derivada. El punt crucial a recordar en aquest cas és que utilitzem un punter per recuperar la classe pare. Quan entra a la classe pare, executa el constructor de classe pare. Aleshores, va a la classe fill i executa el seu constructor. Abans d'executar el destructor de la classe fill, ha d'executar el destructor de la classe pare. El compilador executa el destructor de la classe pare i finalitza la classe sense executar el destructor d'una classe fill. Aquest és el problema; no allibera la memòria de la classe del nen. Representa el constructor d'una classe pare, el constructor d'una classe fill i el destructor d'una classe pare. Això demostra que el destructor d'una classe secundària no s'executa. Després d'aquesta execució, suprimim el punter de la funció main().
Sortida:
Exemple de C++ amb Virtual Destructor
Parlem del destructor virtual amb un codi senzill per diferenciar com funciona amb i sense un destructor virtual.
Codi:
#inclouutilitzant l'espai de noms std ;
classe Parent_Class0
{
públic :
Parent_Class0 ( )
{ cout << 'Constructor de classes pares' << endl ; }
virtual ~Parent_Class0 ( )
{ cout << 'Destructor de la classe dels pares' << endl ; }
} ;
classe Child_1 : públic Parent_Class0
{
públic :
Nen_1 ( )
{ cout << 'Constructor de classe infantil' << endl ; }
virtual ~Child_1 ( )
{ cout << 'Destructor de classe infantil' << endl ; }
} ;
int principal ( )
{
Parent_Class0 * punter = nou Child_1 ( ) ;
esborra el punter ;
tornar 0 ;
}
El primer programa va explicar el problema al qual ens enfrontem sense un destructor virtual. Ara, aquest codi solucionarà aquest problema mitjançant un destructor virtual. Primer, copieu el primer codi i només afegiu una paraula clau en dos llocs d'aquest programa. Aquesta paraula és 'virtual'. Inseriu aquesta paraula amb el destructor de la classe pare, 'Parent_Class0'. De la mateixa manera, esmenta això amb el destructor de la classe fill que és 'Child_1' que es deriva de la classe pare. Aquesta paraula clau 'virtual' fa un petit canvi i executa primer el destructor de la classe infantil 'Child_1'. A continuació, executa el destructor de la classe pare, 'Parent_Class0'. La resta del programa funciona igual que sense un destructor virtual. Afegint aquest petit fragment de codi, podem salvar la nostra memòria de les fuites. Ara, mostra quatre missatges a la consola. Primer, el constructor d'una classe pare, després el constructor d'una classe fill, el destructor d'una classe fill i el destructor d'una classe pare. Al final, eliminem el punter dins del mètode main().
Sortida:
Exemple C++ de Pure Virtual Destructor
En aquest codi, parlarem del destructor virtual pur, de com funciona i de com és diferent d'un destructor virtual.
Codi:
#inclouclasse Parent_0 {
públic :
virtual ~Parent_0 ( ) = 0 ;
} ;
Pare_0 :: ~Parent_0 ( )
{
std :: cout << 'Hola, sóc Pure Destructor. M'has trucat!' ;
}
classe Child_0 : públic Parent_0 {
públic :
~Nil_0 ( ) { std :: cout << 'El destructor derivat és aquí \n ' ; }
} ;
int principal ( )
{
Pare_0 * ptr_0 = nou Child_0 ( ) ;
suprimir ptr_0 ;
tornar 0 ;
}
La classe pare 'Parent_0' es crea al primer pas del codi. Dins d'ell, creeu el destructor principal virtual i assigneu-lo amb 0. Això estableix el destructor virtual com a destructor virtual pur, el que significa que la classe pare ara és abstracta i no podem crear les instàncies d'aquesta classe. Fora de la classe pare 'Parent_0', definiu els destructors i std::cout. El text requerit es mostra utilitzant el std::cout. A continuació, obteniu una classe 'Child_0' de la classe pare i definiu-ne el destructor. Dins del destructor, imprimiu un missatge. A la funció main(), creeu el punter de la classe pare i assigneu-li la classe fill.
El compilador va a la classe pare 'Parent_0'. Quan es crea el punter, el seu constructor es crida automàticament. Aleshores, el compilador entra a la classe fill per invocar el seu constructor. Després de l'execució correcta del constructor, executa el destructor d'una classe fill 'Child_0'. A continuació, executa el destructor d'una classe pare. D'aquesta manera, podem fer un pur destructor virtual. No s'anima a utilitzar-lo perquè utilitzant aquest mètode, la classe pare esdevé abstracta, cosa que la fa inútil. La metodologia que més s'utilitza és el destructor virtual i és una bona pràctica.
Sortida:
Conclusió
Vam aprendre sobre el destructor virtual des del concepte de POO fins a avançar cap als constructors i destructors. Després d'explicar tot això, vam parlar sobre el destructor virtual en detall amb exemples de codificació i destructor virtual pur. Abans d'explicar el destructor virtual, hem de conèixer els constructors, els destructors i l'herència. En l'herència, heretem les classes d'una classe pare. Les classes fills poden ser més d'una, però la classe pare només és una. Els destructors virtuals i els destructors virtuals purs s'apliquen en herència per estalviar-se de la fuga de memòria. Des de l'exemple bàsic fins a l'exemple avançat, vam cobrir tot el que heu de saber per començar a utilitzar i destruir pràcticament la memòria de la classe derivada.