C++ virtuell konstruktør

C Virtuell Konstruktor



C++ gjør det ikke lettere for oss å konstruere virtuelle konstruktører, da det ikke er mulig å overstyre klassens konstruktør. Så, konstruktørvirtualisering er meningsløs. Det er ikke noe konsept for å lage en virtuell konstruktør i et C++-program, men vi kan lage den virtuelle destruktoren der. Vi kan også definere det siden programmering av en konstruktør i C++ ikke kan betraktes som virtuell fordi når en klasses konstruktør kalles opp, inneholder minnet ingen virtuell tabell som indikerer at ingen virtuell peker er opprettet. Dermed bør konstruktøren til enhver tid være ikke-virtuell.

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:

#include
ved 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:

#include
ved 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.