Imidlertid kan en virtuell destruktor eksistere. Her vil vi vise hva som skjer når vi lager en virtuell konstruktør i C++, samt hvordan den virtuelle destruktoren fungerer i stedet for den virtuelle konstruktøren.
Eksempel 1:
La oss lage den virtuelle konstruktøren og begynne koden vår ved å plassere 'iostream'-headerfilen. Denne overskriftsfilen er for funksjonene som er deklarert i den som 'cin' og 'cout'. Etter dette legger vi til 'std' navneområdet, så vi kan ikke legge til denne 'std' med hver funksjon i koden vår. Etter dette lager vi en klasse som er basisklassen til koden vår med navnet 'my_base' og legger deretter til 'public' for å lage den virtuelle konstruktøren.
Den virtuelle konstruktøren opprettes her ved å plassere det 'virtuelle' nøkkelordet. Inne i denne virtuelle konstruktøren plasserer vi en 'cout'-setning. Under dette lager vi en funksjon kalt 'show' der vi bruker 'cout' igjen. Etter dette oppretter vi en avledet klasse av denne basisklassen med navnet 'my_derived' og etablerer deretter 'my_derived()'-konstruktøren i 'public'-feltet. Vi setter inn en 'cout'-setning i denne 'my_derived()'-konstruktøren. Under den konstruerer vi en funksjon som heter «show» hvor vi bruker «cout» en gang til.
Nå, etter å ha påkalt 'main()', lager vi en peker for basisklassen med navnet 'my_ptr' og lager også objektet til den avledede klassen som er 'Obj_d'. Etter dette tildeler vi adressen til 'Obj_d' til 'my_ptr'. Deretter kaller vi «show()»-funksjonen gjennom «my_ptr».
Kode 1:
#include
ved hjelp av navneområde std ;
klasse min_base
{
offentlig :
virtuell min_base ( )
{
cout << 'Her er grunnklassen min' << endl ;
}
tomrom forestilling ( )
{
cout << 'showfunksjonen til basisklassen' << endl ;
}
} ;
klasse min_avledet : offentlig min_base
{
offentlig :
min_avledet ( )
{
cout << 'Her er min avledede klasse' << endl ;
}
tomrom forestilling ( )
{
cout << 'showfunksjonen til avledet klasse' < forestilling ( ) ;
}
Produksjon:
Her viser den en feilmelding som sier at konstruktøren ikke kan erklæres virtuell i C++-programmeringen. Så vi kan se at C++ ikke tillater oss å generere den virtuelle konstruktøren, men vi kan lage den virtuelle destruktoren.
Eksempel 2:
La oss løse det forrige problemet og lage den virtuelle destruktoren i denne koden. Etter å ha erklært 'new_base'-klassen, plasserer vi 'public'-konstruktøren der vi oppretter den virtuelle destruktoren ved å legge til 'virtuell ~' med 'new_base'. Vi setter inn en 'cout'-erklæring i denne virtuelle destruktoren. Under den konstruerer vi en funksjon kalt 'show' som bruker 'cout'. Deretter lager vi en avledet klasse som er 'new_derived' av denne 'new_base'-baseklassen og konstruerer 'new_derived()'-destruktoren i 'public'-feltet. Denne 'new_derived()'-destruktoren har nå en 'cout'-setning lagt til.
Under den lager vi en funksjon kalt 'show' som bruker 'cout'-setningen igjen. Etter å ha kalt 'main()'-funksjonen, produserer vi nå et objekt av den 'obj_d'-avledede klassen samt en peker for basisklassen kalt 'ptr1'. Etter det gir vi 'obj_d'-adressen til 'ptr1'. Deretter påkalles 'show()'-metoden ved å bruke 'ptr1'.
Kode 2:
#includeved hjelp av navneområde std ;
klasse ny_base
{
offentlig :
virtuell ~ny_base ( )
{
cout << 'Basisklassedestruktoren er her' << endl ;
}
tomrom forestilling ( )
{
cout << 'Visfunksjonen til basisklassen' << endl ;
}
} ;
klasse new_derived : offentlig ny_base
{
offentlig :
~ny_avledet ( )
{
cout << 'Den avledede klassedestruktoren er her' << endl ;
}
tomrom forestilling ( )
{
cout << 'Visfunksjonen til basisklassen' < forestilling ( ) ;
}
Produksjon:
Dette programmet bruker et pekerobjekt av 'new_base' som peker til den 'obj_d'-avledede klassen. Dermed kaller den først «show()»-metoden til «new_base»-klassen. Deretter kaller den «~new_derived()»-metoden til «new_derived»-klassen og viser «~new_base» til basisklassen.
Eksempel 3:
Her er en annen kode for å generere den 'virtuelle' konstruktøren. Etter å ha inkludert 'iostream' og 'std' navneområdet, genererer vi en klasse 'B'. Under dette lager vi den 'offentlige' konstruktøren som er 'B()' og genererer deretter 'cout'. Konstruktør- og destruktorfunksjonene er definert ved å bruke en 'offentlig' tilgangsspesifikasjon der ethvert objekt i klassen kan kalle.
Nå lager vi også '~B()'-destruktoren for denne basisklassen der vi bruker 'cout' igjen. Deretter oppretter vi 'D'-klassen, som er den avledede klassen til 'B'-basisklassen, og plasserer den 'offentlige' her. Inne i denne 'publiciteten' lager vi konstruktøren så vel som destruktoren til den avledede klassen med navnene 'D()' og '~D', henholdsvis. Begge inneholder 'cout' inni seg. Nå har vi 'main()'-funksjonen. Etter å ha kalt denne funksjonen, genererer vi pekerobjektet til basisklassen.
Deretter bruker vi nøkkelordet 'delete' og plasserer 'base_ptr' her. I dette tilfellet slettes destruktorens plass ved å kalle pekerobjektet til basisklassen.
Kode 3:
#includeved hjelp av navneområde std ;
klasse B
{
offentlig :
B ( )
{
cout << 'Konstruktør av baseklassen' << endl ;
}
~B ( )
{
cout << 'Destruktor av baseklassen' << endl ;
}
} ;
klasse D : offentlig B
{
offentlig :
D ( )
{
cout << 'Konstruktør av den avledede klassen' << endl ;
}
~D ( )
{
cout << 'Destruktor av den avledede klassen' << endl ;
}
} ;
int hoved- ( )
{
B * base_ptr = ny D ;
slette base_ptr ;
}
Produksjon:
Resultatet viser at den bruker et pekerobjekt som peker på 'B'-klassen i hovedfunksjonen. Dermed kaller den først «konstruktøren()» til «B»-klassen. Deretter kaller den 'konstruktøren()' til 'D'-klassen. Pekerobjektet som holdes av destruktorene i klassene 'B' og 'D' blir deretter slettet. Uten å påkalle destruktoren til 'D'-klassen i programmet, eliminerer 'B'-klassepekeren bare destruktoren til 'B'-klassen. Som et resultat er programmets minne ødelagt.
Konklusjon
Vi diskuterte konseptet 'Virtuell konstruksjon' i C++-programmering. Vi utforsket at vi ikke kan lage den virtuelle konstruktøren i C++, men vi kan lage den virtuelle destruktoren i kodene våre. Her viste vi hva som skjedde da vi opprettet den virtuelle konstruktøren i C++-programmering og hvordan den virtuelle destruktoren fungerer i kodene våre. Vi lærte at konstruktøren ikke kan være virtuell, men vi kan generere den virtuelle destruktoren i klassen vår. Vi demonstrerte noen eksempler og forklarte disse kodene grundig i denne veiledningen.