Pakalbėkime apie OOP, konstruktorius ir naikintojus, dabar pakalbėkime apie virtualius naikintuvus. Virtualūs naikintuvai, kaip nurodo pavadinimas, sunaikina objektą. Turime bazinę klasę ir išvestinę klasę, kuri yra kilusi iš bazinės klasės. Abi klasės turi savo konstruktorius ir naikintojus. Virtualusis naikintuvas išlaisvina prisiminimus, kurie skiriami per išvestinės klasės objektą, o išvestinės klasės objektus ištrina naudojant bazinės klasės žymeklį su „virtualiu“ raktiniu žodžiu.
Kodėl mes naudojame virtualųjį naikintuvą?
Kai baigiasi klasės narių funkcijų vykdymas arba baigiasi main() metodo vykdymas, automatiškai iškviečiamas destruktorius, kad atlaisvintų atmintį, skirtą kuriant objektą. Dabar kodėl mes naudojame virtualų naikintuvą? Kai ištrinama pagrindinė klasė, kuri nurodo išvestinę klasę, čia naudojama rodyklė (*). Bazinės klasės destruktorius iškviečiamas tik šio proceso metu. Išvestinis klasės naikintojas nėra iškviečiamas, todėl kyla problemų. Viena iš jų – atminties nutekėjimo problema. Siekdami išvengti šios problemos ir užtikrinti, kad mūsų kodas būtų saugus, mes praktiškai sunaikiname objektus, kad atlaisvintume vietos atmintyje, kuri buvo skirta kuriant objektus, panaikindami bazinės klasės naikintuvą.
C++ pagrindinis pavyzdys be virtualaus naikintuvo
Pažiūrėkime, kaip programa veikia be virtualaus naikintuvo su paprasta programa, kuri ištrina žymeklį.
Kodas:
#includenaudojant vardų sritį std ;
klasė Parent_Class0
{
viešas :
Tėvų_klasė0 ( )
{ cout << „Tėvų klasės konstruktorius“ << endl ; }
~Parent_Class0 ( )
{ cout << „Tėvų klasės naikintojas“ << endl ; }
} ;
klasė Vaikas_1 : vieša Parent_Class0
{
viešas :
Vaikas_1 ( )
{ cout << „Vaikų klasės konstruktorius“ << endl ; }
~Vaikas_1 ( )
{ cout << „Vaikų klasės griovėjas“ << endl ; }
} ;
tarpt pagrindinis ( )
{
Tėvų_klasė0 * rodyklė = naujas vaikas_1 ( ) ;
ištrinti žymeklį ;
grąžinti 0 ;
}
Šis kodas paaiškina, kaip kodas veikia be virtualaus naikintuvo. Pirmiausia sukurkite klasę pavadinimu „Parent_Class0“, kuri bus pagrindinė klasė. Šioje klasėje sukurkite konstruktorių ir naikintuvą. Kaip žinome, konstruktorius ir naikintojas vadinami taip pat kaip ir klasė. Destruktorius vaizduojamas panašiai kaip konstruktorius, tačiau jis turi simbolį (~), kuris jį skiria nuo konstruktoriaus. Konstruktoriumi ir naikintuvu išspausdinkite pranešimą naudodami „cout<<“. Dabar sukurkite kitą klasę, kuri yra „Vaikas_1“. Ši klasė yra kilusi iš pirminės klasės „Parent_Class0“. Išvestinė klasė turi savo konstruktorių ir naikintuvą, kuriuose yra pranešimas, kurį reikia spausdinti išvesties ekrane.
Naudodami main() metodą, sukuriame „Parent_Class0“ egzempliorių ir priskiriame jam išvestinę klasę. Svarbiausias dalykas, kurį šiuo atveju reikia atsiminti, yra tai, kad mes naudojame žymeklį, kad gautume pagrindinę klasę. Kai jis patenka į pirminę klasę, jis vykdo pagrindinės klasės konstruktorių. Tada jis eina į vaikų klasę ir vykdo savo konstruktorių. Prieš vykdydama antrinės klasės naikintuvą, ji turi vykdyti pirminės klasės naikintoją. Kompiliatorius vykdo pirminės klasės naikintuvą ir nutraukia klasę nevykdęs antrinės klasės naikintuvo. Tai yra problema; tai neišlaisvina vaiko klasės atminties. Jis atstovauja pirminės klasės konstruktorių, antrinės klasės konstruktorių ir pirminės klasės naikintoją. Tai rodo, kad vaikų klasės naikintojas nėra įvykdytas. Po šio vykdymo ištriname žymeklį funkcijoje main().
Išvestis:
C++ pavyzdys su „Virtual Destructor“.
Aptarkime virtualųjį naikintuvą naudodami paprastą kodą, kad atskirtume, kaip jis veikia su virtualiuoju naikintuvu ir be jo.
Kodas:
#includenaudojant vardų sritį std ;
klasė Parent_Class0
{
viešas :
Tėvų_klasė0 ( )
{ cout << „Tėvų klasės konstruktorius“ << endl ; }
virtualus ~Parent_Class0 ( )
{ cout << „Tėvų klasės naikintojas“ << endl ; }
} ;
klasė Vaikas_1 : vieša Parent_Class0
{
viešas :
Vaikas_1 ( )
{ cout << „Vaikų klasės konstruktorius“ << endl ; }
virtualus ~Vaikas_1 ( )
{ cout << „Vaikų klasės griovėjas“ << endl ; }
} ;
tarpt pagrindinis ( )
{
Tėvų_klasė0 * rodyklė = naujas vaikas_1 ( ) ;
ištrinti žymeklį ;
grąžinti 0 ;
}
Pirmoji programa paaiškino problemą, su kuria susiduriame be virtualaus naikintuvo. Dabar šis kodas išspręs šią problemą naudojant virtualų naikintuvą. Pirmiausia nukopijuokite pirmąjį kodą ir tiesiog pridėkite vieną raktinį žodį dviejose šios programos vietose. Tas žodis yra „virtualus“. Įterpkite šį žodį su pagrindinės klasės destruktoriumi „Parent_Class0“. Panašiai paminėkite tai su antrinės klasės naikintuvu, kuris yra „Child_1“, kuris yra kilęs iš pirminės klasės. Šis „virtualus“ raktinis žodis šiek tiek keičia ir pirmiausia įvykdo „Child_1“ vaikų klasės naikintuvą. Tada jis vykdo pagrindinės klasės naikintuvą „Parent_Class0“. Likusi programos dalis veikia taip pat, kaip ir be virtualaus naikintuvo. Pridėję šią mažą kodo dalį galime išsaugoti savo atmintį nuo nutekėjimo. Dabar konsolėje rodomi keturi pranešimai. Pirma, tėvų klasės konstruktorius, tada vaikų klasės kūrėjas, vaikų klasės naikintojas ir tėvų klasės kūrėjas. Galų gale mes ištriname žymeklį main() metodu.
Išvestis:
C++ Pure Virtual Destructor pavyzdys
Šiame kode kalbėsime apie gryną virtualų naikintuvą, kaip jis veikia ir kuo jis skiriasi nuo virtualaus naikintuvo.
Kodas:
#includeklasė Tėvas_0 {
viešas :
virtualus ~Parent_0 ( ) = 0 ;
} ;
Tėvas_0 :: ~ Tėvas_0 ( )
{
std :: cout << 'Sveiki, aš esu grynas naikintojas. Tu mane pašaukei!' ;
}
klasė Vaikas_0 : viešas Tėvas_0 {
viešas :
~Vaikas_0 ( ) { std :: cout << „Išvestinis naikintojas yra čia \n “ ; }
} ;
tarpt pagrindinis ( )
{
Tėvas_0 * ptr_0 = naujas vaikas_0 ( ) ;
ištrinti ptr_0 ;
grąžinti 0 ;
}
Pirminė klasė „Parent_0“ sukuriama pirmame kodo žingsnyje. Jo viduje sukurkite virtualų pirminį naikintuvą ir priskirkite jam 0. Tai nustato virtualųjį naikintuvą į gryną virtualų naikintuvą, o tai reiškia, kad pagrindinė klasė dabar yra abstrakti ir negalime sukurti šios klasės egzempliorių. Už pirminės klasės „Parent_0“ ribų apibrėžkite destruktorius ir std::cout. Reikalingas tekstas rodomas naudojant std::cout. Tada iš pagrindinės klasės išveskite „Child_0“ klasę ir apibrėžkite jos naikintuvą. Destruktoriaus viduje išspausdinkite pranešimą. Funkcijoje main() sukurkite pirminės klasės žymeklį ir priskirkite jai antrinę klasę.
Kompiliatorius eina į pirminę klasę „Parent_0“. Sukūrus žymeklį, automatiškai iškviečiamas jo konstruktorius. Tada kompiliatorius pereina į antrinę klasę, kad iškviestų savo konstruktorių. Sėkmingai įvykdžius konstruktorių, jis įvykdo vaikų klasės „Child_0“ naikintuvą. Tada jis vykdo pagrindinės klasės naikintuvą. Tokiu būdu galime sukurti gryną virtualų naikintoją. Nerekomenduojama jį naudoti, nes naudojant šį metodą pagrindinė klasė tampa abstrakti, todėl ji tampa nenaudinga. Metodika, kuri dažniausiai naudojama, yra virtualus naikintuvas, ir tai yra gera praktika.
Išvestis:
Išvada
Sužinojome apie virtualųjį naikintuvą, pradedant nuo OOP koncepcijos ir pereinant prie konstruktorių ir naikintojų. Visa tai paaiškinę, mes išsamiai aptarėme virtualų naikintuvą su kodavimo pavyzdžiais ir gryną virtualų naikintuvą. Prieš paaiškindami virtualųjį naikintuvą, turime žinoti apie konstruktorius, naikintojus ir paveldėjimą. Paveldėdami, mes paveldime klases iš tėvų klasės. Vaikų klasės gali būti daugiau nei viena, bet pagrindinė klasė yra tik viena. Virtualūs naikintuvai ir gryni virtualūs naikintuvai taikomi paveldėjimui, kad būtų išvengta atminties nutekėjimo. Nuo pagrindinio pavyzdžio iki išplėstinio pavyzdžio apžvelgėme viską, ką turėtumėte žinoti, kad pradėtumėte naudoti ir praktiškai sunaikintumėte išvestinės klasės atmintį.