Virtuell destruktor i C ++
Etter å ha snakket om OOP, konstruktører og destruktører, la oss nå snakke om virtuelle destruktører. De virtuelle destruktørene, som navnet som spesifiserer, ødelegger objektet. Vi har en baseklasse og en avledet klasse som er avledet fra baseklassen. Begge klasser har sine konstruktører og destruktører. Virtuell destructor frigjør erindring som tildeles gjennom det avledede klasseobjektet mens du sletter objektene til den avledede klassen ved hjelp av en baseklassepeker med det "virtuelle" nøkkelordet.
Hvorfor bruker vi den virtuelle destruktøren?
Når utførelsen av klassemedlemsfunksjonene blir utført eller utførelsen av Main () -metoden er i ferd med å avslutte, blir destruktøren automatisk kalt for å frigjøre minnet som blir tildelt under objektopprettelsen. Nå, hvorfor bruker vi en virtuell destruktør? Når baseklassen blir slettet som peker på den avledede klassen, brukes pekeren (*) her. Baseklassedestruktøren kalles bare under denne prosessen. Den avledede klassedestruktøren kalles ikke som fører til problemer. En av dem er et minnelekkasjeproblem. For å unngå dette problemet og gjøre koden vår sikre, ødelegger vi praktisk talt objektene for å frigjøre minneområdet som ble tildelt under opprettelsen av objekter ved å slette baseklassen Destructor.
C ++ grunnleggende eksempel uten virtuell destruktor
La oss se hvordan programmet fungerer uten en virtuell destruktør med et enkelt program som sletter pekeren.
Kode:
#inkludereved hjelp av navneområdet STD;
Klassen Parent_Class0
offentlig:
Parent_class0 ()
cout<< "Parent Class Constructor" <
cout<< "Parent Class Destructor" <
Klassen Child_1: public parent_class0
offentlig:
Child_1 ()
cout<< "Child Class Constructor" <
cout<< "Child Class Destructor" <
int main ()
Parent_Class0*Pointer = new Child_1 ();
slett pekeren;
retur 0;
Denne koden forklarer hvordan koden utføres uten en virtuell destruktør. Først av alt, lag en klasse som heter “Parent_class0” som vil være overordnet klasse. Inne i denne klassen, lage en konstruktør og destruktør. Som vi vet, er konstruktøren og destruktøren kalt den samme som klassen. Destructor er representert på samme måte som konstruktøren, men den har et symbol (~) som skiller det fra konstruktøren. Inne i konstruktøren og destruktøren, skriv ut en melding ved hjelp av “cout<<”. Now, create another class which is “Child_1”. This class is derived from the parent class, “Parent_Class0”. The derived class has its constructor and destructor that contain a message to print on the output screen.
I Main () -metoden lager vi en forekomst av “Parent_Class0” og tildeler en avledet klasse til den. Det avgjørende poenget å huske i dette tilfellet er at vi bruker en peker for å hente foreldreklassen. Når det går inn i foreldreklassen, utfører den foreldreklassekonstruktøren. Deretter går det til barneklassen og utfører konstruktøren. Før den utfører destruktøren av barneklassen, må den utføre ødeleggeren av foreldreklassen. Kompilatoren utfører destruktøren av foreldreklassen og avslutter klassen uten å utføre destruktøren til en barneklasse. Det er problemet; Det frigjør ikke minnet om barnets klasse. Det representerer konstruktøren av en foreldreklasse, konstruktøren av en barneklasse og destruktør av en foreldreklasse. Som viser at destruktøren av en barneklasse ikke blir utført. Etter denne utførelsen sletter vi pekeren i hovedfunksjonen ().
Produksjon:
C ++ Eksempel med virtuell destruktør
La oss diskutere den virtuelle destruktøren med en enkel kode for å skille hvordan den fungerer med og uten en virtuell destruktør.
Kode:
#inkludereved hjelp av navneområdet STD;
Klassen Parent_Class0
offentlig:
Parent_class0 ()
cout<< "Parent Class Constructor" <
cout<< "Parent Class Destructor" <
Klassen Child_1: public parent_class0
offentlig:
Child_1 ()
cout<< "Child Class Constructor" <
cout<< "Child Class Destructor" <
int main ()
Parent_Class0*Pointer = new Child_1 ();
slett pekeren;
retur 0;
Det første programmet forklarte problemet vi står overfor uten en virtuell destruktør. Nå vil denne koden løse det problemet ved hjelp av en virtuell destruktør. Først, kopier 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 Destructor of the Parent Class, “Parent_Class0”. På samme måte, nevn dette med destruktøren av barneklassen som er "Child_1" som er avledet fra foreldreklassen. Dette "virtuelle" nøkkelordet gjør en liten endring, og det utfører destruktøren til "Child_1" barneklassen først. Deretter utfører den destruktøren av foreldreklassen, “Parent_class0”. Resten av programmet fungerer det samme som det fungerer uten en virtuell destruktør. Ved å legge til dette lille kodestykket, kan vi lagre minnet vårt fra lekkasje. Nå viser den fire meldinger på konsollen. Først konstruktøren av en foreldreklasse, deretter konstruktøren av en barneklasse, destruktøren av en barneklasse og destruktøren av en foreldreklasse. Til slutt sletter vi pekeren innenfor Main () -metoden.
Produksjon:
C ++ Eksempel på ren virtuell destruktor
I denne koden vil vi snakke om den rene virtuelle destruktøren, hvordan den fungerer, og hvordan den er forskjellig fra en virtuell destruktør.
Kode:
#inkludereklasse foreldre_0
offentlig:
virtuell ~ parent_0 () = 0;
;
Foreldre_0 :: ~ foreldre_0 ()
std :: cout<< "Hello I am Pure Destructor. You Called Me!";
Klassen Child_0: public Parent_0
offentlig:
~ Child_0 () std :: cout<< "Derived destructor is here\n";
;
int main ()
Foreldre_0* ptr_0 = new Child_0 ();
slett ptr_0;
retur 0;
Foreldreklassen “Parent_0” er opprettet i det første trinnet i koden. Inne i den, oppretter den virtuelle foreldre destruktøren og tilordner den med 0. Dette setter den virtuelle destruktøren til ren virtuell destructor, noe som betyr at foreldreklassen nå er abstrakt og vi ikke kan opprette forekomster av denne klassen. Utenfor foreldreklassen “Parent_0”, definer Destructors and Std :: cout. Den nødvendige teksten vises ved å bruke std :: cout. Deretter kan du utlede en "Child_0" -klasse fra foreldreklassen og definere dens destruktør. Inne i destruktøren, skriv ut en melding. I hovedfunksjonen (), lag pekeren til foreldreklassen og tilordne barneklassen til den.
Kompilatoren går til foreldreklassen “Parent_0”. Når pekeren opprettes, kalles konstruktøren automatisk. Deretter går kompilatoren inn i barneklassen for å påkalle konstruktøren. Etter vellykket henrettelse av konstruktøren, utfører den ødeleggeren av en barneklasse “Child_0”. Deretter utfører den destruktøren til en foreldreklasse. På denne måten kan vi lage en ren virtuell destruktør. Det oppfordres ikke til å bruke den fordi ved å bruke denne metoden blir foreldreklassen abstrakt, noe som gjør den ubrukelig. Metodikken som for det meste brukes er virtuell destruktør, og det er en god praksis.
Produksjon:
Konklusjon
Vi lærte om den virtuelle destruktøren fra konseptet OOP til å bevege seg mot konstruktører og destruktører. Etter å ha forklart alle disse, diskuterte vi om den virtuelle destruktøren i detalj med kodingseksempler og ren virtuell destruktør. Før vi forklarer den virtuelle destruktøren, må vi vite om konstruktører, destruktører og arv. I arv arver vi klassene fra en foreldreklasse. Barneklassene kan være mer enn en, men foreldreklassen er bare en. Virtuelle destruktører og rene virtuelle destruktører brukes i arv for å spare 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 om den avledede klassen.