După ce am vorbit despre OOP, constructori și destructori, să vorbim acum despre destructorii virtuali. Destructorii virtuali, după cum specifică numele, distrug obiectul. Avem o clasă de bază și o clasă derivată care este derivată din clasa de bază. Ambele clase au constructorii și destructorii lor. Destructorul virtual eliberează reminiscențele care sunt alocate prin obiectul clasei derivate în timp ce șterge obiectele clasei derivate folosind un pointer de clasă de bază cu cuvântul cheie „virtual”.
De ce folosim destructorul virtual?
Când execuția funcțiilor membre ale clasei este încheiată sau execuția metodei main() este pe cale să se termine, destructorul este apelat automat pentru a elibera memoria care este alocată în timpul creării obiectului. Acum, de ce folosim un destructor virtual? Când clasa de bază este ștearsă care indică către clasa derivată, aici se folosește indicatorul (*). Destructorul clasei de bază este apelat doar în timpul acestui proces. Destructorul de clasă derivată nu este numit, ceea ce duce la probleme. Una dintre ele este o problemă de scurgere a memoriei. Pentru a evita această problemă și a face codul nostru securizat, practic distrugem obiectele pentru a elibera spațiul de memorie care a fost alocat în timpul creării obiectelor prin ștergerea destructorului clasei de bază.
Exemplu de bază C++ fără Virtual Destructor
Să vedem cum funcționează programul fără un destructor virtual cu un program simplu care șterge pointerul.
Cod:
#includefolosind namespace std ;
clasa Parent_Class0
{
public :
Parent_Class0 ( )
{ cout << „Constructorul clasei părinte” << endl ; }
~Parent_Class0 ( )
{ cout << „Destructor de clasă parentală” << endl ; }
} ;
clasa Copil_1 : public Parent_Class0
{
public :
Copil_1 ( )
{ cout << „Constructor clasa pentru copii” << endl ; }
~Copil_1 ( )
{ cout << „Destructor de clasă pentru copii” << endl ; }
} ;
int principal ( )
{
Parent_Class0 * indicator = nou Copil_1 ( ) ;
șterge indicatorul ;
întoarcere 0 ;
}
Acest cod explică modul în care codul se execută fără un destructor virtual. În primul rând, creați o clasă numită „Parent_Class0” care va fi clasa părinte. În această clasă, creați un constructor și un destructor. După cum știm, constructorul și destructorul sunt denumite la fel ca și clasa. Destructorul este reprezentat în mod similar cu constructorul, dar are un simbol (~) care îl diferențiază de constructor. În interiorul constructorului și al destructorului, tipăriți un mesaj folosind „cout<<”. Acum, creați o altă clasă care este „Child_1”. Această clasă este derivată din clasa părinte, „Parent_Class0”. Clasa derivată are constructorul și destructorul său care conțin un mesaj de tipărit pe ecranul de ieșire.
În metoda main(), creăm o instanță a „Parent_Class0” și îi atribuim o clasă derivată. Punctul crucial de reținut în acest caz este că folosim un pointer pentru a prelua clasa părinte. Când intră în clasa părinte, execută constructorul clasei părinte. Apoi, merge la clasa copil și își execută constructorul. Înainte de a executa destructorul clasei copil, acesta trebuie să execute destructorul clasei părinte. Compilatorul execută destructorul clasei părinte și termină clasa fără a executa destructorul unei clase copil. Aceasta este problema; nu eliberează memoria clasei copilului. Reprezintă constructorul unei clase părinte, constructorul unei clase copil și destructorul unei clase părinte. Asta arată că destructorul unei clase copil nu este executat. După această execuție, ștergem pointerul din funcția main().
Ieșire:
Exemplu C++ cu Virtual Destructor
Să discutăm despre destructorul virtual cu un cod simplu pentru a diferenția modul în care funcționează cu și fără un destructor virtual.
Cod:
#includefolosind namespace std ;
clasa Parent_Class0
{
public :
Parent_Class0 ( )
{ cout << „Constructorul clasei părinte” << endl ; }
virtual ~Parent_Class0 ( )
{ cout << „Destructor de clasă parentală” << endl ; }
} ;
clasa Copil_1 : public Parent_Class0
{
public :
Copil_1 ( )
{ cout << „Constructor clasa pentru copii” << endl ; }
virtual ~Copil_1 ( )
{ cout << „Destructor de clasă pentru copii” << endl ; }
} ;
int principal ( )
{
Parent_Class0 * indicator = nou Copil_1 ( ) ;
șterge indicatorul ;
întoarcere 0 ;
}
Primul program a explicat problema cu care ne confruntăm fără un destructor virtual. Acum, acest cod va rezolva problema folosind un destructor virtual. Mai întâi, copiați primul cod și adăugați doar un cuvânt cheie în două locuri în acest program. Acest cuvânt este „virtual”. Introduceți acest cuvânt cu destructorul clasei părinte, „Parent_Class0”. În mod similar, menționați acest lucru cu destructorul clasei copil care este „Child_1” care este derivat din clasa părinte. Acest cuvânt cheie „virtual” face o mică schimbare și execută mai întâi destructorul clasei copil „Child_1”. Apoi, execută destructorul clasei părinte, „Parent_Class0”. Restul programului funcționează la fel cum funcționează fără un destructor virtual. Adăugând această mică bucată de cod, ne putem salva memoria de scurgeri. Acum, afișează patru mesaje pe consolă. Mai întâi, constructorul unei clase părinte, apoi constructorul unei clase copil, destructorul unei clase copil și destructorul unei clase părinte. În final, ștergem indicatorul din metoda main().
Ieșire:
Exemplu C++ de Pure Virtual Destructor
În acest cod, vom vorbi despre destructorul virtual pur, cum funcționează și cum este diferit de un destructor virtual.
Cod:
#includeclasa Parent_0 {
public :
virtual ~Parent_0 ( ) = 0 ;
} ;
Parent_0 :: ~Părinte_0 ( )
{
std :: cout << 'Bună, sunt un distrugător pur. M-ai chemat!' ;
}
clasa Copil_0 : public Parent_0 {
public :
~Copil_0 ( ) { std :: cout << „Destructorul derivat este aici \n ' ; }
} ;
int principal ( )
{
Parent_0 * ptr_0 = nou Copil_0 ( ) ;
ștergeți ptr_0 ;
întoarcere 0 ;
}
Clasa părinte „Parent_0” este creată în primul pas al codului. În interiorul acestuia, creați destructorul părinte virtual și atribuiți-l cu 0. Acest lucru setează destructorul virtual la destructor virtual pur, ceea ce înseamnă că clasa părinte este acum abstractă și nu putem crea instanțe ale acestei clase. În afara clasei părinte „Parent_0”, definiți destructorii și std::cout. Textul necesar este afișat prin utilizarea std::cout. Apoi, deduceți o clasă „Child_0” din clasa părinte și definiți destructorul acesteia. În interiorul destructorului, imprimați un mesaj. În funcția main(), creați pointerul clasei părinte și atribuiți-i clasa copil.
Compilatorul merge la clasa părinte „Parent_0”. Când pointerul este creat, constructorul său este apelat automat. Apoi, compilatorul intră în clasa copil pentru a-și invoca constructorul. După executarea cu succes a constructorului, acesta execută destructorul unei clase copil „Child_0”. Apoi, execută destructorul unei clase părinte. În acest fel, putem face un pur destructor virtual. Nu este încurajat să-l folosească deoarece prin folosirea acestei metode, clasa părinte devine abstractă, ceea ce o face inutilă. Metodologia folosită cel mai mult este destructorul virtual și este o bună practică.
Ieșire:
Concluzie
Am învățat despre destructorul virtual pornind de la conceptul de POO până la deplasarea către constructori și destructori. După ce le-am explicat toate acestea, am discutat despre destructorul virtual în detaliu cu exemple de codare și destructor virtual pur. Înainte de a explica destructorul virtual, trebuie să știm despre constructori, destructori și moștenire. În moștenire, moștenim clasele de la o clasă părinte. Clasele copil pot fi mai multe, dar clasa părinte este doar una. Destructorii virtuali și destructorii virtuali puri sunt aplicați în moștenire pentru a salva de la pierderea memoriei. De la exemplul de bază la exemplul avansat, am acoperit tot ce ar trebui să știți pentru a începe să utilizați și să distrugeți virtual memoria clasei derivate.