Tanmateix, podria existir un destructor virtual. Aquí, mostrarem què passa quan creem un constructor virtual en C++, així com el funcionament del destructor virtual en lloc del constructor virtual.
Exemple 1:
Creem el constructor virtual i comencem el nostre codi col·locant el fitxer de capçalera 'iostream'. Aquest fitxer de capçalera és per a les funcions que s'hi declaren com 'cin' i 'cout'. Després d'això, afegim l'espai de noms 'std', de manera que no podem afegir aquest 'std' amb totes les funcions del nostre codi. Després d'això, creem una classe que és la classe base del nostre codi amb el nom 'my_base' i després afegim 'public' per crear el constructor virtual.
El constructor virtual es crea aquí col·locant la paraula clau 'virtual'. Dins d'aquest constructor virtual, col·loquem una declaració 'cout'. A sota d'això, creem una funció anomenada 'mostrar' en la qual tornem a utilitzar el 'cout'. Després d'això, creem una classe derivada d'aquesta classe base amb el nom 'my_derived' i després establim el constructor 'my_derived()' al camp 'public'. Inseriu una instrucció 'cout' en aquest constructor 'my_derived()'. A sota, construïm una funció anomenada 'mostrar' on fem ús del 'cout' una vegada més.
Ara, després d'invocar el 'main()', creem un punter de la classe base amb el nom 'my_ptr' i també creem l'objecte de la classe derivada que és 'Obj_d'. Després d'això, assignem l'adreça del 'Obj_d' al 'my_ptr'. Aleshores, anomenem la funció 'show()' mitjançant 'my_ptr'.
Codi 1:
#inclou
utilitzant espai de noms std ;
classe la meva_base
{
públic :
virtual la meva_base ( )
{
cout << 'Aquí està la meva classe bàsica' << endl ;
}
buit espectacle ( )
{
cout << 'la funció d'espectacle de la classe base' << endl ;
}
} ;
classe la meva_derivada : públic la meva_base
{
públic :
la meva_derivada ( )
{
cout << 'Aquí està la meva classe derivada' << endl ;
}
buit espectacle ( )
{
cout << 'la funció de mostra de la classe derivada' < espectacle ( ) ;
}
Sortida:
Aquí, mostra un missatge d'error que diu que el constructor no es pot declarar virtual a la programació C++. Així doncs, podem veure que C++ no ens permet generar el constructor virtual, però podem crear el destructor virtual.
Exemple 2:
Anem a resoldre el problema anterior i crear el destructor virtual en aquest codi. Després de declarar la classe 'new_base', col·loquem el constructor 'públic' en el qual creem el destructor virtual afegint 'virtual ~' amb la 'new_base'. Inseriu una declaració 'cout' en aquest destructor virtual. A sota, construïm una funció anomenada 'mostrar' que fa ús del 'cout'. A continuació, fem una classe derivada que és 'new_derived' d'aquesta classe base 'new_base' i construïm el destructor 'new_derived()' al camp 'públic'. Aquest destructor 'new_derived()' ara té una declaració 'cout' afegida.
A sota, creem una funció anomenada 'mostrar' que torna a utilitzar la declaració 'cout'. Després de cridar la funció 'main()', ara produïm un objecte de la classe derivada 'obj_d' així com un punter de la classe base anomenat 'ptr1'. Després d'això, donem l'adreça 'obj_d' al 'ptr1'. A continuació, s'invoca el mètode 'show()' mitjançant 'ptr1'.
Codi 2:
#inclouutilitzant espai de noms std ;
classe nova_base
{
públic :
virtual ~nova_base ( )
{
cout << 'El destructor de la classe base és aquí' << endl ;
}
buit espectacle ( )
{
cout << 'La funció d'espectacle de la classe base' << endl ;
}
} ;
classe nou_derivat : públic nova_base
{
públic :
~nou_derivat ( )
{
cout << 'El destructor de classes derivats és aquí' << endl ;
}
buit espectacle ( )
{
cout << 'La funció d'espectacle de la classe base' < espectacle ( ) ;
}
Sortida:
Aquest programa utilitza un objecte punter de la 'new_base' que apunta a la classe derivada 'obj_d'. Per tant, crida primer al mètode 'show()' de la classe 'new_base'. A continuació, crida al mètode '~new_derived()' de la classe 'new_derived' i mostra la '~new_base' de la classe base.
Exemple 3:
Aquí hi ha un altre codi per generar el constructor 'virtual'. Després d'incloure l'espai de noms 'iostream' i 'std', generem una classe 'B'. A sota, creem el constructor 'públic' que és 'B()' i després generem el 'cout'. Les funcions de constructor i destructor es defineixen utilitzant un especificador d'accés 'públic' al qual qualsevol objecte de la classe pot cridar.
Ara, també creem el destructor '~B()' d'aquesta classe base en què tornem a utilitzar el 'cout'. A continuació, creem la classe 'D' que és la classe derivada de la classe base 'B' i col·loquem el 'públic' aquí. Dins d'aquest 'públic', creem el constructor així com el destructor de la classe derivada amb els noms 'D()' i '~D', respectivament. Tots dos contenen el 'cout' al seu interior. Ara, tenim la funció 'main()'. Després de cridar aquesta funció, generem l'objecte punter de la classe base.
A continuació, fem servir la paraula clau 'eliminar' i col·loquem 'base_ptr' aquí. En aquest cas, l'espai del destructor s'elimina cridant l'objecte punter de la classe base.
Codi 3:
#includeutilitzant espai de noms std ;
classe B
{
públic :
B ( )
{
cout << 'Constructor de la classe Base' << endl ;
}
~B ( )
{
cout << 'Destructor de la classe Base' << endl ;
}
} ;
classe D : públic B
{
públic :
D ( )
{
cout << 'Constructor de la classe derivada' << endl ;
}
~D ( )
{
cout << 'Destructor de la classe derivada' << endl ;
}
} ;
int principal ( )
{
B * base_ptr = nou D ;
esborrar base_ptr ;
}
Sortida:
El resultat mostra que utilitza un objecte punter que apunta a la classe 'B' a la funció principal. Per tant, crida primer al 'constructor()' de la classe 'B'. Aleshores, crida al 'constructor()' de la classe 'D'. A continuació, s'elimina l'objecte punter que tenen els destructors de les classes 'B' i 'D'. Sense invocar el destructor de la classe 'D' dins del programa, el punter de la classe 'B' només elimina el destructor de la classe 'B'. Com a resultat, la memòria del programa està malmesa.
Conclusió
Hem parlat del concepte de 'construcció virtual' a la programació C++. Hem explorat que no podem crear el constructor virtual en C++, però podem crear el destructor virtual als nostres codis. Aquí, vam mostrar què va passar quan creem el constructor virtual en programació C++ i el funcionament del destructor virtual als nostres codis. Hem après que el constructor no pot ser virtual, però podem generar el destructor virtual a la nostra classe. Hem demostrat alguns exemples i hem explicat aquests codis a fons en aquesta guia.