Der kunne dog eksistere en virtuel destruktor. Her vil vi vise, hvad der sker, når vi opretter en virtuel konstruktør i C++ såvel som den virtuelle destruktors funktion i stedet for den virtuelle konstruktør.
Eksempel 1:
Lad os oprette den virtuelle konstruktør og begynde vores kode ved at placere 'iostream'-headerfilen. Denne overskriftsfil er til de funktioner, der er erklæret i den som 'cin' og 'cout'. Herefter tilføjer vi 'std' navnerummet, så vi kan ikke tilføje denne 'std' med hver funktion i vores kode. Efter dette opretter vi en klasse, som er basisklassen for vores kode med navnet 'my_base' og tilføjer derefter 'public' for at skabe den virtuelle konstruktør.
Den virtuelle konstruktør oprettes her ved at placere det 'virtuelle' nøgleord. Inde i denne virtuelle konstruktør placerer vi en 'cout'-erklæring. Herunder opretter vi en funktion ved navn 'show', hvor vi igen bruger 'cout'. Efter dette opretter vi en afledt klasse af denne basisklasse med navnet 'my_derived' og etablerer derefter 'my_derived()'-konstruktøren i feltet 'public'. Vi indsætter en 'cout'-sætning i denne 'my_derived()'-konstruktør. Under den konstruerer vi en funktion kaldet 'show', hvor vi igen gør brug af 'cout'.
Nu, efter at have påkaldt 'main()', opretter vi en pointer for basisklassen med navnet 'my_ptr' og opretter også objektet for den afledte klasse, som er 'Obj_d'. Efter dette tildeler vi adressen på 'Obj_d' til 'my_ptr'. Derefter kalder vi 'show()'-funktionen gennem 'my_ptr'.
Kode 1:
#include
ved brug af navneområde std ;
klasse min_base
{
offentlig :
virtuelle min_base ( )
{
cout << 'Her er min basisklasse' << endl ;
}
ugyldig at vise ( )
{
cout << 'show-funktionen af basisklassen' << endl ;
}
} ;
klasse mit_afledte : offentlig min_base
{
offentlig :
mit_afledte ( )
{
cout << 'Her er min afledte klasse' << endl ;
}
ugyldig at vise ( )
{
cout << 'show-funktionen af afledt klasse' < at vise ( ) ;
}
Produktion:
Her viser den en fejlmeddelelse, der siger, at konstruktøren ikke kan erklæres virtuel i C++-programmeringen. Så vi kan se, at C++ ikke tillader os at generere den virtuelle konstruktør, men vi kan oprette den virtuelle destruktor.
Eksempel 2:
Lad os løse det forrige problem og oprette den virtuelle destruktor i denne kode. Efter at have erklæret 'new_base'-klassen, placerer vi den 'public' konstruktør, hvori vi opretter den virtuelle destructor ved at tilføje 'virtuel ~' med 'new_base'. Vi indsætter en 'cout'-erklæring i denne virtuelle destruktor. Under den konstruerer vi en funktion kaldet 'show', der gør brug af 'cout'. Dernæst laver vi en afledt klasse, som er 'new_derived' af denne 'new_base'-basisklasse og konstruerer 'new_derived()'-destruktoren i feltet 'public'. Denne 'new_derived()'-destruktor har nu en 'cout'-sætning tilføjet.
Under den opretter vi en funktion kaldet 'show', der bruger 'cout'-sætningen igen. Efter at have kaldt 'main()'-funktionen, producerer vi nu et objekt af den 'obj_d'-afledte klasse samt en pointer for basisklassen ved navn 'ptr1'. Efter det giver vi 'obj_d'-adressen til 'ptr1'. Dernæst kaldes 'show()'-metoden ved hjælp af 'ptr1'.
Kode 2:
#includeved brug af navneområde std ;
klasse ny_base
{
offentlig :
virtuelle ~ny_base ( )
{
cout << 'Basisklassedestruktoren er her' << endl ;
}
ugyldig at vise ( )
{
cout << 'Basisklassens showfunktion' << endl ;
}
} ;
klasse new_derived : offentlig ny_base
{
offentlig :
~nyt_afledt ( )
{
cout << 'Den afledte klassedestruktor er her' << endl ;
}
ugyldig at vise ( )
{
cout << 'Basisklassens showfunktion' < at vise ( ) ;
}
Produktion:
Dette program bruger et pointerobjekt fra 'new_base', der peger på den 'obj_d'-afledte klasse. Således kalder den først 'show()'-metoden for klassen 'new_base'. Derefter kalder den '~new_derived()'-metoden for klassen 'new_derived' og viser '~new_base' for basisklassen.
Eksempel 3:
Her er en anden kode til at generere den 'virtuelle' konstruktør. Efter at have inkluderet 'iostream' og 'std' navneområdet, genererer vi en klasse 'B'. Herunder opretter vi den 'offentlige' konstruktør, som er 'B()' og genererer derefter 'cout'. Konstruktør- og destruktorfunktionerne er defineret ved at bruge en 'offentlig' adgangsspecifikation, hvori ethvert objekt i klassen kan kalde.
Nu opretter vi også '~B()'-destruktoren for denne basisklasse, hvor vi bruger 'cout' igen. Derefter opretter vi 'D'-klassen, som er den afledte klasse af 'B'-basisklassen og placerer 'offentligheden' her. Inde i denne 'public' opretter vi konstruktøren såvel som destruktoren for den afledte klasse med navnene 'D()' og '~D'. Begge indeholder 'cout' inde i dem. Nu har vi funktionen 'main()'. Efter at have kaldt denne funktion genererer vi pointerobjektet for basisklassen.
Derefter bruger vi nøgleordet 'delete' og placerer 'base_ptr' her. I dette tilfælde slettes destruktorens plads ved at kalde pointerobjektet for basisklassen.
Kode 3:
#includeved brug af navneområde std ;
klasse B
{
offentlig :
B ( )
{
cout << 'Konstruktør af basisklassen' << endl ;
}
~B ( )
{
cout << 'Destruktor af Base-klassen' << endl ;
}
} ;
klasse D : offentlig B
{
offentlig :
D ( )
{
cout << 'Konstruktør af den afledte klasse' << endl ;
}
~D ( )
{
cout << 'Destruktor af den afledte klasse' << endl ;
}
} ;
int vigtigste ( )
{
B * base_ptr = ny D ;
slette base_ptr ;
}
Produktion:
Resultatet viser, at det bruger et pointerobjekt, der peger på 'B'-klassen i hovedfunktionen. Således kalder den først 'constructor()' af 'B'-klassen. Derefter kalder den 'constructor()' af 'D'-klassen. Pointerobjektet, der holdes af destruktorerne af 'B' og 'D' klasserne, slettes derefter. Uden at påkalde destruktoren af 'D'-klassen i programmet, eliminerer 'B'-klassemarkøren kun destruktoren for 'B'-klassen. Som følge heraf er programmets hukommelse ødelagt.
Konklusion
Vi diskuterede konceptet 'Virtuel konstruktion' i C++ programmering. Vi undersøgte, at vi ikke kan oprette den virtuelle konstruktør i C++, men vi kan lave den virtuelle destruktor i vores koder. Her viste vi, hvad der skete, da vi oprettede den virtuelle konstruktør i C++-programmering og den virtuelle destruktors funktion i vores koder. Vi lærte, at konstruktøren ikke kan være virtuel, men vi kan generere den virtuelle destruktor i vores klasse. Vi demonstrerede nogle eksempler og forklarede disse koder grundigt i denne vejledning.