Pēc runāšanas par OOP, konstruktoriem un iznīcinātājiem, tagad parunāsim par virtuālajiem iznīcinātājiem. Virtuālie iznīcinātāji, kā norāda nosaukums, iznīcina objektu. Mums ir bāzes klase un atvasināta klase, kas ir atvasināta no bāzes klases. Abām klasēm ir savi konstruktori un iznīcinātāji. Virtuālais iznīcinātājs atbrīvo atmiņas, kas tiek piešķirtas caur atvasināto klases objektu, vienlaikus dzēšot atvasinātās klases objektus, izmantojot bāzes klases rādītāju ar “virtuālo” atslēgvārdu.
Kāpēc mēs izmantojam virtuālo iznīcinātāju?
Kad klases dalībnieka funkciju izpilde ir pabeigta vai main() metodes izpilde tuvojas beigām, tiek automātiski izsaukts destruktors, lai atbrīvotu atmiņu, kas tiek piešķirta objekta izveides laikā. Tagad, kāpēc mēs izmantojam virtuālo iznīcinātāju? Kad tiek dzēsta bāzes klase, kas norāda uz atvasināto klasi, šeit tiek izmantots rādītājs (*). Bāzes klases destruktors tiek izsaukts tikai šī procesa laikā. Atvasinātais klases iznīcinātājs netiek izsaukts, kas rada problēmas. Viens no tiem ir atmiņas noplūdes problēma. Lai izvairītos no šīs problēmas un padarītu mūsu kodu drošu, mēs praktiski iznīcinām objektus, lai atbrīvotu vietu atmiņā, kas tika piešķirta objektu izveides laikā, dzēšot bāzes klases iznīcinātāju.
C++ pamata piemērs bez virtuālā iznīcinātāja
Apskatīsim, kā programma darbojas bez virtuāla destruktora ar vienkāršu programmu, kas izdzēš rādītāju.
Kods:
#includeizmantojot namespace std ;
klase Vecāki_klase0
{
publiski :
Vecāku_klase0 ( )
{ cout << 'Vecāku klases konstruktors' << endl ; }
~Vecāku_klase0 ( )
{ cout << 'Vecāku klases iznīcinātājs' << endl ; }
} ;
klase Bērns_1 : publiska Parent_Class0
{
publiski :
Bērns_1 ( )
{ cout << 'Bērnu klases konstruktors' << endl ; }
~Bērns_1 ( )
{ cout << 'Bērnu klases iznīcinātājs' << endl ; }
} ;
starpt galvenais ( )
{
Vecāku_klase0 * rādītājs = jauns bērns_1 ( ) ;
dzēst rādītāju ;
atgriezties 0 ;
}
Šis kods izskaidro, kā kods tiek izpildīts bez virtuāla iznīcinātāja. Vispirms izveidojiet klasi ar nosaukumu “Parent_Class0”, kas būs vecākklase. Šajā klasē izveidojiet konstruktoru un iznīcinātāju. Kā zināms, konstruktors un iznīcinātājs tiek nosaukti tāpat kā klase. Destruktors tiek attēlots līdzīgi kā konstruktors, bet tam ir simbols (~), kas to atšķir no konstruktora. Konstruktora un destruktora iekšpusē izdrukājiet ziņojumu, izmantojot “cout<<”. Tagad izveidojiet citu klasi, kas ir “Bērns_1”. Šī klase ir atvasināta no vecākklases “Parent_Class0”. Atvasinātajai klasei ir savs konstruktors un iznīcinātājs, kas satur ziņojumu, kas jādrukā izvades ekrānā.
Main() metodē mēs izveidojam “Parent_Class0” gadījumu un piešķiram tai atvasinātu klasi. Izšķirošais punkts, kas jāatceras šajā gadījumā, ir tas, ka mēs izmantojam rādītāju, lai izgūtu vecāku klasi. Kad tas nonāk vecākklasē, tas izpilda vecākklases konstruktoru. Pēc tam tas nonāk bērnu klasē un izpilda savu konstruktoru. Pirms bērnklases iznīcinātāja izpildes tai ir jāizpilda vecākklases iznīcinātājs. Kompilators izpilda vecākklases iznīcinātāju un pabeidz klasi, neizpildot bērnklases iznīcinātāju. Tā ir problēma; tas neatbrīvo atmiņu par bērna klasi. Tas apzīmē vecāku klases konstruktoru, bērnu klases konstruktoru un vecāku klases iznīcinātāju. Tas parāda, ka bērnu klases iznīcinātājs netiek izpildīts. Pēc šīs izpildes mēs izdzēšam rādītāju main() funkcijā.
Izvade:
C++ piemērs ar Virtual Destructor
Apspriedīsim virtuālo iznīcinātāju ar vienkāršu kodu, lai atšķirtu, kā tas darbojas ar virtuālo iznīcinātāju un bez tā.
Kods:
#includeizmantojot namespace std ;
klase Vecāki_klase0
{
publiski :
Vecāku_klase0 ( )
{ cout << 'Vecāku klases konstruktors' << endl ; }
virtuālā ~ Parent_Class0 ( )
{ cout << 'Vecāku klases iznīcinātājs' << endl ; }
} ;
klase Bērns_1 : publiska Parent_Class0
{
publiski :
Bērns_1 ( )
{ cout << 'Bērnu klases konstruktors' << endl ; }
virtuāls ~Bērns_1 ( )
{ cout << 'Bērnu klases iznīcinātājs' << endl ; }
} ;
starpt galvenais ( )
{
Vecāku_klase0 * rādītājs = jauns bērns_1 ( ) ;
dzēst rādītāju ;
atgriezties 0 ;
}
Pirmā programma izskaidroja problēmu, ar kuru mēs saskaramies bez virtuālā iznīcinātāja. Tagad šis kods atrisinās šo problēmu, izmantojot virtuālo iznīcinātāju. Vispirms nokopējiet pirmo kodu un vienkārši pievienojiet vienu atslēgvārdu divās vietās šajā programmā. Šis vārds ir 'virtuāls'. Ievietojiet šo vārdu ar vecākklases destruktoru “Parent_Class0”. Tāpat norādiet to ar bērnklases iznīcinātāju, kas ir “Bērns_1”, kas ir atvasināts no vecākklases. Šis “virtuālais” atslēgvārds ievieš nelielas izmaiņas, un tas vispirms izpilda bērnu klases “Child_1” iznīcinātāju. Pēc tam tas izpilda vecāku klases iznīcinātāju “Parent_Class0”. Pārējā programma darbojas tāpat kā bez virtuālā iznīcinātāja. Pievienojot šo mazo koda fragmentu, mēs varam saglabāt savu atmiņu no noplūdes. Tagad tas konsolē parāda četrus ziņojumus. Pirmkārt, vecāku klases konstruktors, pēc tam bērnu klases konstruktors, bērnu klases iznīcinātājs un vecāku klases konstruētājs. Beigās mēs izdzēšam rādītāju main() metodes ietvaros.
Izvade:
C++ Pure Virtual Destructor piemērs
Šajā kodā mēs runāsim par tīro virtuālo iznīcinātāju, kā tas darbojas un kā tas atšķiras no virtuālā iznīcinātāja.
Kods:
#includeklase Vecāks_0 {
publiski :
virtuāls ~ Parent_0 ( ) = 0 ;
} ;
Vecāks_0 :: ~Vecāks_0 ( )
{
std :: cout << 'Sveiki, es esmu tīrais iznīcinātājs. Jūs mani saucāt!' ;
}
klase Bērns_0 : publisks Vecāks_0 {
publiski :
~Bērns_0 ( ) { std :: cout << 'Atvasinātais iznīcinātājs ir šeit \n ' ; }
} ;
starpt galvenais ( )
{
Vecāks_0 * ptr_0 = jauns bērns_0 ( ) ;
dzēst ptr_0 ;
atgriezties 0 ;
}
Pirmajā koda darbībā tiek izveidota vecāku klase “Parent_0”. Tajā izveidojiet virtuālo vecāku iznīcinātāju un piešķiriet tam 0. Tādējādi virtuālais iznīcinātājs tiek iestatīts uz tīru virtuālo iznīcinātāju, kas nozīmē, ka vecākklase tagad ir abstrakta un mēs nevaram izveidot šīs klases gadījumus. Ārpus vecāku klases “Vecāks_0” definējiet iznīcinātājus un std::cout. Nepieciešamais teksts tiek parādīts, izmantojot std::cout. Pēc tam no vecākklases atvasiniet klasi “Child_0” un definējiet tās iznīcinātāju. Destruktora iekšpusē izdrukājiet ziņojumu. Funkcijā main() izveidojiet vecākklases rādītāju un piešķiriet tai bērnu klasi.
Kompilators pāriet uz vecāku klasi “Parent_0”. Kad rādītājs ir izveidots, automātiski tiek izsaukts tā konstruktors. Pēc tam kompilators pāriet uz bērnu klasi, lai izsauktu savu konstruktoru. Pēc konstruktora veiksmīgas izpildes tas izpilda bērnu klases “Bērns_0” destruktoru. Pēc tam tas izpilda vecāku klases iznīcinātāju. Tādā veidā mēs varam izveidot tīru virtuālu iznīcinātāju. Nav ieteicams to izmantot, jo, izmantojot šo metodi, vecāku klase kļūst abstrakta, kas padara to bezjēdzīgu. Visbiežāk izmantotā metodoloģija ir virtuālais destruktors, un tā ir laba prakse.
Izvade:
Secinājums
Mēs uzzinājām par virtuālo iznīcinātāju, sākot no OOP koncepcijas un beidzot ar konstruktoriem un iznīcinātājiem. Pēc visu to izskaidrošanas mēs detalizēti apspriedām virtuālo iznīcinātāju ar kodēšanas piemēriem un tīru virtuālo iznīcinātāju. Pirms izskaidrot virtuālo iznīcinātāju, mums jāzina par konstruktoriem, iznīcinātājiem un mantojumu. Mantojumā mēs mantojam klases no vecāku klases. Bērnu klases var būt vairākas, bet vecāku klase ir tikai viena. Virtuālie iznīcinātāji un tīri virtuālie iznīcinātāji tiek izmantoti mantojumā, lai glābtu no atmiņas noplūdes. No pamata piemēra līdz uzlabotajam piemēram mēs apskatījām visu, kas jums jāzina, lai sāktu lietot un praktiski iznīcinātu atvasinātās klases atmiņu.