Etter å ha snakket om OOP, konstruktører og destruktorer, la oss nå snakke om virtuelle destruktorer. De virtuelle ødeleggerne, som navnet spesifiserer, ødelegger objektet. Vi har en grunnklasse og en avledet klasse som er avledet fra grunnklassen. Begge klassene har sine konstruktører og destruktorer. Virtual destructor frigjør erindring som tildeles gjennom det avledede klasseobjektet mens objektene til den avledede klassen slettes ved å bruke en baseklassepeker med det 'virtuelle' nøkkelordet.
Hvorfor bruker vi Virtual Destructor?
Når kjøringen av klassemedlemsfunksjonene er fullført eller kjøringen av main()-metoden er i ferd med å avsluttes, kalles destruktoren automatisk for å frigjøre minnet som er tildelt under objektopprettingen. Nå, hvorfor bruker vi en virtuell destruktor? Når grunnklassen slettes som peker på den avledede klassen, brukes pekeren (*) her. Basisklassedestruktoren kalles bare under denne prosessen. Den avledede klassedestruktoren kalles ikke, noe som fører til problemer. En av dem er et problem med minnelekkasje. For å unngå dette problemet og gjøre koden vår sikker, ødelegger vi praktisk talt objektene for å frigjøre minneplassen som ble tildelt under opprettelsen av objekter ved å slette grunnklassedestruktoren.
C++ Grunnleggende eksempel uten Virtual Destructor
La oss se hvordan programmet fungerer uten en virtuell destruktor med et enkelt program som sletter pekeren.
Kode:
#includebruker navneområde std ;
klasse Foreldre_Klasse0
{
offentlig :
Foreldre_Klasse0 ( )
{ cout << 'Foreldreklassekonstruktør' << endl ; }
~Foreldreklasse0 ( )
{ cout << 'Foreldreklassedestruktor' << endl ; }
} ;
klasse Barn_1 : offentlig Foreldre_Klasse0
{
offentlig :
Barn_1 ( )
{ cout << 'Barneklassekonstruktør' << endl ; }
~Barn_1 ( )
{ cout << 'Barneklassedestruktor' << endl ; }
} ;
int hoved- ( )
{
Foreldre_Klasse0 * pekeren = nytt barn_1 ( ) ;
slett pekeren ;
komme tilbake 0 ;
}
Denne koden forklarer hvordan koden kjøres uten en virtuell destruktor. Først av alt, opprett en klasse kalt 'Parent_Class0' som vil være den overordnede klassen. Inne i denne klassen, lag en konstruktør og destruktor. Som vi vet, heter konstruktøren og destruktoren det samme som klassen. Destruktoren er representert på samme måte som konstruktøren, men den har et symbol (~) som skiller den fra konstruktøren. Inne i konstruktøren og destruktoren skriver du ut en melding med 'cout<<'. Opprett nå en annen klasse som er 'Child_1'. Denne klassen er avledet fra den overordnede klassen, 'Prent_Class0'. Den avledede klassen har sin konstruktør og destruktor som inneholder en melding som skal skrives ut på utdataskjermen.
I main()-metoden lager vi en forekomst av 'Parent_Class0' og tilordner en avledet klasse til den. Det avgjørende poenget å huske i dette tilfellet er at vi bruker en peker for å hente den overordnede klassen. Når den går inn i den overordnede klassen, kjører den den overordnede klassekonstruktøren. Deretter går den til barneklassen og utfører konstruktøren. Før den utfører destruktoren til underklassen, må den utføre destructoren til den overordnede klassen. Kompilatoren kjører destruktoren til den overordnede klassen og avslutter klassen uten å kjøre destruktoren til en barneklasse. Det er problemet; det frigjør ikke minnet om barnets klasse. Den representerer konstruktøren av en overordnet klasse, konstruktøren av en barneklasse og destruktoren til en overordnet klasse. Det viser at ødeleggeren av en barneklasse ikke blir henrettet. Etter denne utførelsen sletter vi pekeren i hoved()-funksjonen.
Produksjon:
C++ Eksempel med Virtual Destructor
La oss diskutere den virtuelle destruktoren med en enkel kode for å skille hvordan den fungerer med og uten en virtuell destruktor.
Kode:
#includebruker navneområde std ;
klasse Foreldre_Klasse0
{
offentlig :
Foreldre_Klasse0 ( )
{ cout << 'Foreldreklassekonstruktør' << endl ; }
virtuell ~Foreldreklasse0 ( )
{ cout << 'Foreldreklassedestruktor' << endl ; }
} ;
klasse Barn_1 : offentlig Foreldre_Klasse0
{
offentlig :
Barn_1 ( )
{ cout << 'Barneklassekonstruktør' << endl ; }
virtuell ~Child_1 ( )
{ cout << 'Barneklassedestruktor' << endl ; }
} ;
int hoved- ( )
{
Foreldre_Klasse0 * pekeren = nytt barn_1 ( ) ;
slett pekeren ;
komme tilbake 0 ;
}
Det første programmet forklarte problemet vi står overfor uten en virtuell destruktor. Nå vil denne koden løse det problemet ved å bruke en virtuell destruktor. Først kopierer du den første koden og legger bare til ett nøkkelord to steder i dette programmet. Det ordet er 'virtuelt'. Sett inn dette ordet med destruktoren til overordnet klasse, 'Parent_Class0'. På samme måte nevner du dette med destruktoren til barneklassen, som er 'Child_1' som er avledet fra overordnet klasse. Dette 'virtuelle' søkeordet gjør en liten endring, og det kjører destruktoren til barneklassen 'Child_1' først. Deretter kjører den destruktoren til overordnet klasse, 'Parent_Class0'. Resten av programmet fungerer på samme måte som det fungerer uten en virtuell destruktor. Ved å legge til denne lille kodebiten kan vi redde minnet vårt fra lekkasje. Nå viser den fire meldinger på konsollen. Først konstruktøren av en overordnet klasse, deretter konstruktøren av en barneklasse, destruktoren av en barneklasse og destruktoren til en overordnet klasse. Til slutt sletter vi pekeren i main()-metoden.
Produksjon:
C++ Eksempel på Pure Virtual Destructor
I denne koden vil vi snakke om den rene virtuelle destruktoren, hvordan den fungerer, og hvordan den er forskjellig fra en virtuell destruktor.
Kode:
#includeklasse Foreldre_0 {
offentlig :
virtuell ~Foreldre_0 ( ) = 0 ;
} ;
Foreldre_0 :: ~Foreldre_0 ( )
{
std :: cout << 'Hei jeg er Pure Destructor. Du ringte meg!' ;
}
klasse Barn_0 : offentlig forelder_0 {
offentlig :
~Barn_0 ( ) { std :: cout << 'Derivert destruktor er her \n ' ; }
} ;
int hoved- ( )
{
Foreldre_0 * ptr_0 = nytt barn_0 ( ) ;
slett ptr_0 ;
komme tilbake 0 ;
}
Foreldreklassen 'Parent_0' opprettes i det første trinnet i koden. Inne i den, lag den virtuelle overordnede destruktoren og tilordne den med 0. Dette setter den virtuelle destruktoren til ren virtuell destruktor, noe som betyr at den overordnede klassen nå er abstrakt og vi kan ikke opprette forekomstene av denne klassen. Utenfor overordnet klasse 'Parent_0', definer destruktorene og std::cout. Den nødvendige teksten vises ved å bruke std::cout. Deretter utleder en 'Child_0'-klasse fra den overordnede klassen og definer dens destruktor. Skriv ut en melding inne i destruktoren. I main()-funksjonen oppretter du pekeren til den overordnede klassen og tilordner den underordnede klassen til den.
Kompilatoren går til den overordnede klassen 'Parent_0'. Når pekeren er opprettet, kalles konstruktøren automatisk. Deretter går kompilatoren inn i barneklassen for å påkalle konstruktøren. Etter vellykket kjøring av konstruktøren, kjører den destruktoren til en barneklasse 'Child_0'. Deretter utfører den destruktoren til en overordnet klasse. På denne måten kan vi lage en ren virtuell destruktor. Det oppfordres ikke til å bruke det fordi ved å bruke denne metoden blir overordnet klassen abstrakt som gjør den ubrukelig. Metoden som brukes mest er virtuell destruktor, og det er en god praksis.
Produksjon:
Konklusjon
Vi lærte om den virtuelle destruktoren fra konseptet OOP til å bevege oss mot konstruktørene og destruktorene. Etter å ha forklart alle disse, diskuterte vi om den virtuelle destruktoren i detalj med kodeeksempler og ren virtuell destruktor. Før vi forklarer den virtuelle destruktoren, må vi vite om konstruktørene, destruktorene og arven. I arv arver vi klassene fra en foreldreklasse. Barneklassene kan være flere enn én, men foreldreklassen er bare én. Virtuelle destruktorer og rene virtuelle destruktorer brukes i arv for å redde fra minnelekkasjen. Fra det grunnleggende eksemplet til det avanserte eksemplet dekket vi alt du bør vite for å komme i gang med å bruke og praktisk talt ødelegge minnet til den avledede klassen.