OOP:sta, rakentajista ja tuhoajista puhumisen jälkeen puhutaan nyt virtuaalisista tuhoajista. Nimen mukaan virtuaaliset tuhoajat tuhoavat kohteen. Meillä on perusluokka ja johdettu luokka, joka on johdettu perusluokasta. Molemmilla luokilla on rakentajansa ja tuhoajansa. Virtuaalinen tuhoaja vapauttaa muistot, jotka jaetaan johdetun luokkaobjektin kautta, samalla kun se poistaa johdetun luokan objektit käyttämällä perusluokan osoitinta 'virtuaali'-avainsanalla.
Miksi käytämme Virtual Destructoria?
Kun luokan jäsenfunktiot on suoritettu tai main()-metodin suoritus on päättymässä, destruktoria kutsutaan automaattisesti vapauttamaan objektin luonnin aikana varattu muisti. Miksi käytämme virtuaalista tuhoajaa? Kun perusluokka poistetaan, joka osoittaa johdettuun luokkaan, osoitinta (*) käytetään tässä. Perusluokan tuhoajaa kutsutaan vain tämän prosessin aikana. Johdettua luokkadestruktoria ei kutsuta, mikä johtaa ongelmiin. Yksi niistä on muistivuotoongelma. Tämän ongelman välttämiseksi ja koodimme turvallisuuden varmistamiseksi tuhoamme objektit käytännössä vapauttaaksemme objektien luomisen aikana varatun muistitilan poistamalla perusluokan tuhoajan.
C++-perusesimerkki ilman Virtual Destructoria
Katsotaan kuinka ohjelma toimii ilman virtuaalista tuhoajaa yksinkertaisella ohjelmalla, joka poistaa osoittimen.
Koodi:
#includekäyttämällä nimiavaruutta std ;
luokka Vanhempi_luokka0
{
julkinen :
Vanhempi_luokka0 ( )
{ cout << 'Vanhempiluokan rakentaja' << endl ; }
~Vanhempi_luokka0 ( )
{ cout << 'Parent Class Destructor' << endl ; }
} ;
luokka Lapsi_1 : julkinen vanhempi_luokka0
{
julkinen :
Lapsi_1 ( )
{ cout << 'Lapsiluokan rakentaja' << endl ; }
~Lapsi_1 ( )
{ cout << 'Lapsiluokan tuhoaja' << endl ; }
} ;
int pää ( )
{
Vanhempi_luokka0 * osoitin = uusi lapsi_1 ( ) ;
poista osoitin ;
palata 0 ;
}
Tämä koodi selittää kuinka koodi suoritetaan ilman virtuaalista tuhoajaa. Luo ensin luokka nimeltä 'Parent_Class0', josta tulee pääluokka. Luo tämän luokan sisällä rakentaja ja tuhoaja. Kuten tiedämme, rakentaja ja tuhoaja on nimetty samalla tavalla kuin luokka. Destruktori esitetään samalla tavalla kuin konstruktori, mutta siinä on symboli (~), joka erottaa sen konstruktorista. Tulosta konstruktorin ja destructorin sisällä viesti käyttämällä 'cout<<'. Luo nyt toinen luokka, joka on 'Lapsi_1'. Tämä luokka on johdettu pääluokasta 'Parent_Class0'. Johdetulla luokalla on rakentaja ja destruktori, jotka sisältävät viestin tulostenäytölle.
Main()-menetelmässä luomme esiintymän 'Parent_Class0':sta ja määritämme sille johdetun luokan. Ratkaiseva seikka, joka on muistettava tässä tapauksessa, on, että käytämme osoitinta pääluokan hakemiseen. Kun se menee yläluokkaan, se suorittaa yläluokan rakentajan. Sitten se menee lapsiluokkaan ja suorittaa sen rakentajan. Ennen kuin aliluokan tuhoaja suoritetaan, sen on suoritettava emoluokan destructor. Kääntäjä suorittaa emoluokan destruktorin ja lopettaa luokan suorittamatta aliluokan tuhoajaa. Se on ongelma; se ei vapauta lapsen luokan muistia. Se edustaa yläluokan rakentajaa, aliluokan rakentajaa ja yläluokan tuhoajaa. Tämä osoittaa, että lapsiluokan tuhoajaa ei teloiteta. Tämän suorituksen jälkeen poistamme main()-funktion osoittimen.
Lähtö:
C++ esimerkki Virtual Destructorilla
Keskustellaan virtuaalihävittäjästä yksinkertaisen koodin avulla erottaaksemme, miten se toimii virtuaalisen tuhoajan kanssa ja ilman sitä.
Koodi:
#includekäyttäen nimiavaruutta std ;
luokka Vanhempi_luokka0
{
julkinen :
Vanhempi_luokka0 ( )
{ cout << 'Vanhempiluokan rakentaja' << endl ; }
virtuaalinen ~Parent_Class0 ( )
{ cout << 'Parent Class Destructor' << endl ; }
} ;
luokka Lapsi_1 : julkinen vanhempi_luokka0
{
julkinen :
Lapsi_1 ( )
{ cout << 'Lapsiluokan rakentaja' << endl ; }
virtuaalinen ~lapsi_1 ( )
{ cout << 'Lapsiluokan tuhoaja' << endl ; }
} ;
int pää ( )
{
Vanhempi_luokka0 * osoitin = uusi lapsi_1 ( ) ;
poista osoitin ;
palata 0 ;
}
Ensimmäinen ohjelma selitti ongelman, jonka kohtaamme ilman virtuaalista tuhoajaa. Nyt tämä koodi ratkaisee tämän ongelman käyttämällä virtuaalista tuhoajaa. Kopioi ensin ensimmäinen koodi ja lisää vain yksi avainsana kahteen paikkaan tässä ohjelmassa. Tämä sana on 'virtuaali'. Lisää tämä sana pääluokan 'Parent_Class0' -destruktorin kanssa. Mainitse tämä samalla tavalla aliluokan tuhoajan kanssa, joka on 'Lapsi_1', joka on johdettu yläluokasta. Tämä 'virtuaalinen' avainsana tekee pienen muutoksen ja suorittaa ensin lapsiluokan 'Lapsi_1' tuhoajan. Sitten se suorittaa emoluokan tuhoajan 'Parent_Class0'. Muu ohjelma toimii samalla tavalla kuin se toimii ilman virtuaalista tuhoajaa. Lisäämällä tämän pienen koodinpätkän voimme säästää muistimme vuodolta. Nyt se näyttää neljä viestiä konsolissa. Ensin vanhemman luokan rakentaja, sitten aliluokan rakentaja, alaluokan tuhoaja ja yläluokan tuhoaja. Lopulta poistamme osoittimen main()-metodissa.
Lähtö:
C++ Esimerkki Pure Virtual Destructorista
Tässä koodissa puhumme puhtaasta virtuaalihävittäjästä, miten se toimii ja miten se eroaa virtuaalisesta tuhoajasta.
Koodi:
#includeluokan vanhempi_0 {
julkinen :
virtuaalinen ~Parent_0 ( ) = 0 ;
} ;
Vanhempi_0 :: ~Vanhempi_0 ( )
{
std :: cout << 'Hei, olen Pure Destructor. Sinä soitit minulle!' ;
}
luokka Lapsi_0 : julkinen vanhempi_0 {
julkinen :
~Lapsi_0 ( ) { std :: cout << 'Johdettu tuhoaja on täällä \n ' ; }
} ;
int pää ( )
{
Vanhempi_0 * ptr_0 = uusi lapsi_0 ( ) ;
poista ptr_0 ;
palata 0 ;
}
Yläluokka “Parent_0” luodaan koodin ensimmäisessä vaiheessa. Luo sen sisällä virtuaalinen ylätuottaja ja anna sille arvo 0. Tämä asettaa virtuaalihävittäjän puhtaaksi virtuaaliseksi tuhoajaksi, mikä tarkoittaa, että emoluokka on nyt abstrakti, emmekä voi luoda tämän luokan ilmentymiä. Pääluokan “Parent_0” ulkopuolella määritä destruktorit ja std::cout. Vaadittu teksti näytetään käyttämällä std::cout. Johda sitten luokka 'Lapsi_0' pääluokasta ja määritä sen tuhoaja. Tulosta viesti tuhoajan sisällä. Luo main()-funktiossa pääluokan osoitin ja määritä sille aliluokka.
Kääntäjä siirtyy yläluokkaan 'Parent_0'. Kun osoitin on luotu, sen rakentaja kutsutaan automaattisesti. Sitten kääntäjä menee lapsiluokkaan kutsuakseen rakentajansa. Kun konstruktori on suoritettu onnistuneesti, se suorittaa aliluokan 'Lapsi_0' destruktorin. Sitten se suorittaa emoluokan tuhoajan. Tällä tavalla voimme tehdä puhtaan virtuaalisen tuhoajan. Sitä ei kannusteta käyttämään, koska tätä menetelmää käyttämällä emoluokka muuttuu abstraktiksi, mikä tekee siitä hyödyttömän. Eniten käytetty menetelmä on virtuaalinen tuhoaja ja se on hyvä käytäntö.
Lähtö:
Johtopäätös
Opimme virtuaalihävittäjästä OOP:n käsitteestä siirtymiseen kohti rakentajia ja tuhoajia. Kaiken tämän selityksen jälkeen keskustelimme virtuaalihävittäjästä yksityiskohtaisesti koodausesimerkeillä ja puhtaalla virtuaalihävittäjällä. Ennen kuin selitämme virtuaalisen destruktorin, meidän on tiedettävä rakentajat, tuhoajat ja periytyminen. Perinnössä perimme luokat vanhemmalta luokalta. Lapsiluokkaa voi olla useampi kuin yksi, mutta yläluokka on vain yksi. Virtuaalisia tuhoajia ja puhtaita virtuaalisia tuhoajia sovelletaan perintönä muistivuotojen säästämiseksi. Perusesimerkistä edistyneeseen esimerkkiin käsittelimme kaiken, mitä sinun pitäisi tietää, jotta voit aloittaa käytön ja käytännössä tuhota johdetun luokan muistin.