Pagkatapos pag-usapan ang OOP, mga constructor, at destructors, pag-usapan natin ngayon ang tungkol sa mga virtual na destructor. Ang mga virtual na destructors, gaya ng tinukoy ng pangalan, ay sirain ang bagay. Mayroon kaming base class at derived class na hinango sa base class. Ang parehong mga klase ay may kanilang mga constructor at destructors. Ang virtual destructor ay nagpapalaya sa pag-alaala na inilalaan sa pamamagitan ng nagmula na object ng klase habang tinatanggal ang mga bagay ng nagmula na klase gamit ang isang base class pointer na may 'virtual' na keyword.
Bakit Namin Ginagamit ang Virtual Destructor?
Kapag ang pagpapatupad ng mga function ng miyembro ng klase ay tapos na o ang pagpapatupad ng pangunahing() na pamamaraan ay malapit nang matapos, ang destructor ay awtomatikong tinatawag upang palayain ang memorya na inilalaan sa panahon ng paglikha ng bagay. Ngayon, bakit tayo gumagamit ng virtual na destructor? Kapag ang batayang klase ay tinanggal na tumuturo sa nagmula na klase, ang pointer (*) ay ginagamit dito. Ang base class destructor ay tinatawag lamang sa prosesong ito. Ang derived class destructor ay hindi tinatawag na humahantong sa mga isyu. Ang isa sa mga ito ay isang isyu sa pagtagas ng memorya. Upang maiwasan ang isyung ito at gawing secure ang aming code, halos sinisira namin ang mga bagay upang palayain ang memory space na inilaan sa paggawa ng mga bagay sa pamamagitan ng pagtanggal ng base class destructor.
C++ Basic na Halimbawa nang walang Virtual Destructor
Tingnan natin kung paano gumagana ang programa nang walang virtual destructor na may simpleng program na nagtatanggal ng pointer.
Code:
#includegamit ang namespace std ;
klase Parent_Class0
{
pampubliko :
Parent_Class0 ( )
{ cout << 'Parent Class Constructor' << endl ; }
~Parent_Class0 ( )
{ cout << 'Parent Class Destructor' << endl ; }
} ;
klase Bata_1 : pampublikong Parent_Class0
{
pampubliko :
Bata_1 ( )
{ cout << 'Child Class Constructor' << endl ; }
~Bata_1 ( )
{ cout << 'Child Class Destructor' << endl ; }
} ;
int pangunahing ( )
{
Parent_Class0 * panturo = bagong Bata_1 ( ) ;
tanggalin ang pointer ;
bumalik 0 ;
}
Ipinapaliwanag ng code na ito kung paano ine-execute ang code nang walang virtual destructor. Una sa lahat, lumikha ng isang klase na pinangalanang 'Parent_Class0' na magiging parent class. Sa loob ng klase na ito, lumikha ng isang constructor at destructor. Tulad ng alam natin, ang constructor at destructor ay pinangalanang pareho sa klase. Ang destructor ay kinakatawan katulad ng constructor ngunit ito ay may simbolo (~) na nag-iiba nito mula sa constructor. Sa loob ng constructor at destructor, mag-print ng mensahe gamit ang 'cout<<'. Ngayon, lumikha ng isa pang klase na 'Child_1'. Ang klase na ito ay hinango sa parent class, 'Parent_Class0'. Ang nagmula na klase ay may constructor at destructor nito na naglalaman ng mensaheng ipi-print sa output screen.
Sa pangunahing() na pamamaraan, lumikha kami ng isang halimbawa ng 'Parent_Class0' at nagtatalaga ng isang nagmula na klase dito. Ang mahalagang punto na dapat tandaan sa kasong ito ay ang paggamit namin ng isang pointer upang makuha ang parent class. Kapag pumasok ito sa loob ng parent class, ipapatupad nito ang parent class constructor. Pagkatapos, pupunta ito sa klase ng bata at ipapatupad ang constructor nito. Bago i-execute ang destructor ng child class, kailangan nitong i-execute ang destructor ng parent class. Isinasagawa ng compiler ang destructor ng parent class at tinatapos ang klase nang hindi pinapagana ang destructor ng isang child class. Iyan ang problema; hindi nito pinapalaya ang memorya ng klase ng bata. Kinakatawan nito ang constructor ng isang parent class, ang constructor ng isang child class, at ang destructor ng isang parent class. Iyon ay nagpapakita na ang destructor ng isang klase ng bata ay hindi naisakatuparan. Pagkatapos ng pagpapatupad na ito, tatanggalin namin ang pointer sa main() function.
Output:
Halimbawa ng C++ na may Virtual Destructor
Talakayin natin ang virtual na destructor gamit ang isang simpleng code upang makilala kung paano ito gumagana sa at walang virtual na destructor.
Code:
#includegamit ang namespace std ;
klase Parent_Class0
{
pampubliko :
Parent_Class0 ( )
{ cout << 'Parent Class Constructor' << endl ; }
virtual ~Parent_Class0 ( )
{ cout << 'Parent Class Destructor' << endl ; }
} ;
klase Bata_1 : pampublikong Parent_Class0
{
pampubliko :
Bata_1 ( )
{ cout << 'Child Class Constructor' << endl ; }
virtual ~Bata_1 ( )
{ cout << 'Child Class Destructor' << endl ; }
} ;
int pangunahing ( )
{
Parent_Class0 * panturo = bagong Bata_1 ( ) ;
tanggalin ang pointer ;
bumalik 0 ;
}
Ipinaliwanag ng unang programa ang problemang kinakaharap natin nang walang virtual na destructor. Ngayon, malulutas ng code na ito ang problemang iyon gamit ang isang virtual destructor. Una, kopyahin ang unang code at magdagdag lamang ng isang keyword sa dalawang lugar sa program na ito. Ang salitang iyon ay 'virtual'. Ipasok ang salitang ito kasama ang destructor ng parent class, 'Parent_Class0'. Katulad nito, banggitin ito kasama ang destructor ng child class na 'Child_1' na hinango sa parent class. Ang 'virtual' na keyword na ito ay gumagawa ng kaunting pagbabago at ito ang unang nagpapatupad ng destructor ng 'Child_1' na klase ng bata. Pagkatapos, ipapatupad nito ang destructor ng parent class, 'Parent_Class0'. Ang natitirang bahagi ng programa ay nagpapatakbo ng katulad ng ito ay nagpapatakbo nang walang virtual na destructor. Sa pamamagitan ng pagdaragdag ng maliit na piraso ng code na ito, maililigtas natin ang ating memorya mula sa pagtagas. Ngayon, nagpapakita ito ng apat na mensahe sa console. Una, ang constructor ng isang parent class, pagkatapos ay ang constructor ng isang child class, ang destructor ng isang child class, at ang destructor ng isang parent class. Sa huli, tinatanggal namin ang pointer sa loob ng pangunahing() na pamamaraan.
Output:
C++ Halimbawa ng Pure Virtual Destructor
Sa code na ito, pag-uusapan natin ang tungkol sa purong virtual na destructor, kung paano ito gumagana, at kung paano ito naiiba sa isang virtual na destructor.
Code:
#includeklase Magulang_0 {
pampubliko :
virtual ~Magulang_0 ( ) = 0 ;
} ;
Magulang_0 :: ~Magulang_0 ( )
{
std :: cout << 'Hello I am Pure Destructor. You Called Me!' ;
}
klase Bata_0 : pampublikong Magulang_0 {
pampubliko :
~Bata_0 ( ) { std :: cout << 'Narito ang derived destructor \n ' ; }
} ;
int pangunahing ( )
{
Magulang_0 * ptr_0 = bagong Bata_0 ( ) ;
tanggalin ang ptr_0 ;
bumalik 0 ;
}
Ang parent class na “Parent_0” ay ginawa sa unang hakbang ng code. Sa loob nito, likhain ang virtual parent destructor at italaga ito ng 0. Itinatakda nito ang virtual na destructor sa purong virtual na destructor na nangangahulugan na ang parent class ay abstract na ngayon at hindi tayo makakagawa ng mga instance ng klase na ito. Sa labas ng parent class na 'Parent_0', tukuyin ang mga destructors at std::cout. Ang kinakailangang teksto ay ipinapakita sa pamamagitan ng paggamit ng std::cout. Pagkatapos, kumuha ng 'Child_0' na klase mula sa parent class at tukuyin ang destructor nito. Sa loob ng destructor, mag-print ng mensahe. Sa main() function, lumikha ng pointer ng parent class at italaga ang child class dito.
Ang compiler ay pupunta sa parent class na 'Parent_0'. Kapag nalikha ang pointer, awtomatikong tinatawag ang constructor nito. Pagkatapos, ang compiler ay napupunta sa klase ng bata upang i-invoke ang constructor nito. Matapos ang matagumpay na pagpapatupad ng constructor, ipapatupad nito ang destructor ng isang child class na 'Child_0'. Pagkatapos, ipapatupad nito ang destructor ng isang parent class. Sa ganitong paraan, makakagawa tayo ng purong virtual destructor. Hindi hinihikayat na gamitin ito dahil sa paggamit ng pamamaraang ito, nagiging abstract ang parent class na ginagawang walang silbi. Ang pamamaraan na kadalasang ginagamit ay virtual destructor at ito ay isang magandang kasanayan.
Output:
Konklusyon
Natutunan namin ang tungkol sa virtual na destructor simula sa konsepto ng OOP hanggang sa paglipat patungo sa mga constructor at destructor. Matapos ipaliwanag ang lahat ng ito, tinalakay namin ang tungkol sa virtual destructor nang detalyado sa mga halimbawa ng coding at purong virtual na destructor. Bago ipaliwanag ang virtual destructor, dapat nating malaman ang tungkol sa mga constructor, destructors, at inheritance. Sa inheritance, minana namin ang mga klase mula sa isang parent class. Ang mga klase ng bata ay maaaring higit sa isa ngunit ang klase ng magulang ay isa lamang. Ang mga virtual na destructor at purong virtual na mga destructor ay inilalapat sa mana upang makatipid mula sa pagtagas ng memorya. Mula sa pangunahing halimbawa hanggang sa advanced na halimbawa, sinakop namin ang lahat ng dapat mong malaman upang makapagsimulang gumamit at halos sirain ang memorya ng nagmula na klase.