అయితే, వర్చువల్ డిస్ట్రక్టర్ ఉండవచ్చు. ఇక్కడ, మేము C++లో వర్చువల్ కన్స్ట్రక్టర్ను సృష్టించినప్పుడు ఏమి జరుగుతుందో అలాగే వర్చువల్ కన్స్ట్రక్టర్‌కు బదులుగా వర్చువల్ డిస్ట్రక్టర్ యొక్క పనిని చూపుతాము.
ఉదాహరణ 1:
వర్చువల్ కన్స్ట్రక్టర్ని క్రియేట్ చేద్దాం మరియు 'iostream' హెడర్ ఫైల్‌ను ఉంచడం ద్వారా మా కోడ్‌ను ప్రారంభిద్దాం. ఈ హెడర్ ఫైల్‌లో “సిన్” మరియు “కౌట్” వంటి డిక్లేర్ చేయబడిన ఫంక్షన్‌ల కోసం ఉద్దేశించబడింది. దీని తర్వాత, మేము “std” నేమ్‌స్పేస్‌ని జోడిస్తాము, కాబట్టి మన కోడ్‌లోని ప్రతి ఫంక్షన్‌తో ఈ “std”ని జోడించలేము. దీని తర్వాత, మేము 'my_base' పేరుతో మా కోడ్ యొక్క బేస్ క్లాస్ అయిన క్లాస్‌ని క్రియేట్ చేస్తాము మరియు వర్చువల్ కన్స్ట్రక్టర్ని సృష్టించడానికి 'పబ్లిక్'ని జోడిస్తాము.
'వర్చువల్' కీవర్డ్‌ని ఉంచడం ద్వారా వర్చువల్ కన్స్ట్రక్టర్ ఇక్కడ సృష్టించబడుతుంది. ఈ వర్చువల్ కన్స్ట్రక్టర్ లోపల, మేము 'కౌట్' స్టేట్‌మెంట్‌ను ఉంచుతాము. దీని క్రింద, మేము 'షో' అనే పేరుతో ఒక ఫంక్షన్‌ను సృష్టిస్తాము, దీనిలో మేము మళ్లీ 'కౌట్' ను ఉపయోగిస్తాము. దీని తర్వాత, మేము 'my_derived' పేరుతో ఈ బేస్ క్లాస్ యొక్క ఉత్పన్నమైన తరగతిని సృష్టించి, ఆపై 'పబ్లిక్' ఫీల్డ్‌లో 'my_derived()' కన్స్ట్రక్టర్ని ఏర్పాటు చేస్తాము. మేము ఈ “my_derived()” కన్‌స్ట్రక్టర్‌లో “కౌట్” స్టేట్‌మెంట్‌ను ఇన్సర్ట్ చేస్తాము. దాని క్రింద, మేము 'షో' అనే ఫంక్షన్‌ను నిర్మిస్తాము, ఇక్కడ మేము మరోసారి 'కౌట్'ని ఉపయోగిస్తాము.
ఇప్పుడు, “main()”ని ప్రారంభించిన తర్వాత, మేము “my_ptr” పేరుతో బేస్ క్లాస్ యొక్క పాయింటర్‌ను సృష్టిస్తాము మరియు “Obj_d” అనే ఉత్పన్నమైన తరగతి యొక్క వస్తువును కూడా సృష్టిస్తాము. దీని తర్వాత, మేము 'Obj_d' చిరునామాను 'my_ptr'కి కేటాయిస్తాము. అప్పుడు, మేము 'show()' ఫంక్షన్‌ని 'my_ptr' ద్వారా పిలుస్తాము.
కోడ్ 1:
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి నా_బేస్
{
ప్రజా :
వర్చువల్ నా_బేస్ ( )
{
కోట్ << 'ఇదిగో నా బేస్ క్లాస్' << endl ;
}
శూన్యం చూపించు ( )
{
కోట్ << 'బేస్ క్లాస్ యొక్క షో ఫంక్షన్' << endl ;
}
} ;
తరగతి నా_ఉత్పన్నం : ప్రజా నా_బేస్
{
ప్రజా :
నా_ఉత్పన్నం ( )
{
కోట్ << 'ఇదిగో నా డెరైవ్డ్ క్లాస్' << endl ;
}
శూన్యం చూపించు ( )
{
కోట్ << 'ఉత్పన్న తరగతి యొక్క ప్రదర్శన ఫంక్షన్' < చూపించు ( ) ;
}
అవుట్‌పుట్:
ఇక్కడ, ఇది C++ ప్రోగ్రామింగ్‌లో కన్స్ట్రక్టర్ని వర్చువల్‌గా ప్రకటించలేమని చెప్పే దోష సందేశాన్ని చూపుతుంది. కాబట్టి, వర్చువల్ కన్స్ట్రక్టర్ను రూపొందించడానికి C++ మమ్మల్ని అనుమతించదని మనం చూడవచ్చు కానీ మనం వర్చువల్ డిస్ట్రక్టర్‌ను సృష్టించవచ్చు.
ఉదాహరణ 2:
మునుపటి సమస్యను పరిష్కరించి, ఈ కోడ్‌లో వర్చువల్ డిస్ట్రక్టర్‌ని క్రియేట్ చేద్దాం. “new_base” తరగతిని ప్రకటించిన తర్వాత, “new_base”తో “వర్చువల్ ~” జోడించడం ద్వారా మేము వర్చువల్ డిస్ట్రక్టర్‌ని సృష్టించే “పబ్లిక్” కన్స్ట్రక్టర్ను ఉంచుతాము. మేము ఈ వర్చువల్ డిస్ట్రక్టర్‌లో “కౌట్” స్టేట్‌మెంట్‌ను ఇన్సర్ట్ చేస్తాము. దాని క్రింద, మేము 'కౌట్'ని ఉపయోగించుకునే 'షో' అనే ఫంక్షన్‌ని నిర్మిస్తాము. తరువాత, మేము ఈ 'new_base' బేస్ క్లాస్ నుండి 'new_derived' ఒక ఉత్పన్నమైన తరగతిని తయారు చేస్తాము మరియు 'public' ఫీల్డ్‌లో 'new_derived()'డిస్ట్రక్టర్‌ని నిర్మిస్తాము. ఈ “new_derived()” డిస్ట్రక్టర్ ఇప్పుడు దానికి “cout” స్టేట్‌మెంట్ జోడించబడింది.
దాని క్రింద, మేము 'కౌట్' స్టేట్‌మెంట్‌ను మళ్లీ ఉపయోగించే 'షో' అనే ఫంక్షన్‌ను సృష్టిస్తాము. “main()” ఫంక్షన్‌కు కాల్ చేసిన తర్వాత, మేము ఇప్పుడు “obj_d” ఉత్పన్నమైన తరగతి యొక్క ఆబ్జెక్ట్‌ను అలాగే “ptr1” అనే బేస్ క్లాస్ యొక్క పాయింటర్‌ను ఉత్పత్తి చేస్తాము. దానిని అనుసరించి, మేము “ptr1”కి “obj_d” చిరునామాను ఇస్తాము. తర్వాత, “ptr1”ని ఉపయోగించి “show()” పద్ధతి అమలు చేయబడుతుంది.
కోడ్ 2:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి కొత్త_బేస్
{
ప్రజా :
వర్చువల్ ~కొత్త_బేస్ ( )
{
కోట్ << 'బేస్ క్లాస్ డిస్ట్రక్టర్ ఇక్కడ ఉంది' << endl ;
}
శూన్యం చూపించు ( )
{
కోట్ << 'బేస్ క్లాస్ యొక్క ప్రదర్శన ఫంక్షన్' << endl ;
}
} ;
తరగతి కొత్త_ఉత్పన్నం : ప్రజా కొత్త_బేస్
{
ప్రజా :
~కొత్త_ఉత్పన్నం ( )
{
కోట్ << 'ఉత్పన్న తరగతి డిస్ట్రక్టర్ ఇక్కడ ఉంది' << endl ;
}
శూన్యం చూపించు ( )
{
కోట్ << 'బేస్ క్లాస్ యొక్క ప్రదర్శన ఫంక్షన్' < చూపించు ( ) ;
}
అవుట్‌పుట్:
ఈ ప్రోగ్రామ్ 'new_base' యొక్క పాయింటర్ ఆబ్జెక్ట్‌ను ఉపయోగిస్తుంది, అది 'obj_d' ఉత్పన్నమైన తరగతిని సూచిస్తుంది. అందువలన, ఇది 'new_base' క్లాస్ యొక్క 'షో()' పద్ధతిని ముందుగా పిలుస్తుంది. అప్పుడు, ఇది 'new_derived' క్లాస్ యొక్క '~new_derived()' పద్ధతిని పిలుస్తుంది మరియు బేస్ క్లాస్ యొక్క '~new_base'ని ప్రదర్శిస్తుంది.
ఉదాహరణ 3:
'వర్చువల్' కన్స్ట్రక్టర్ను రూపొందించడానికి ఇక్కడ మరొక కోడ్ ఉంది. “iostream” మరియు “std” నేమ్‌స్పేస్‌ని చేర్చిన తర్వాత, మేము క్లాస్ “B”ని రూపొందిస్తాము. దీని క్రింద, మేము “పబ్లిక్” కన్స్ట్రక్టర్ని “B()”ని సృష్టించి, ఆపై “కౌట్”ని రూపొందిస్తాము. క్లాస్‌లోని ఏదైనా వస్తువు కాల్ చేయగల “పబ్లిక్” యాక్సెస్ స్పెసిఫైయర్‌ని ఉపయోగించడం ద్వారా కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్ ఫంక్షన్‌లు నిర్వచించబడతాయి.
ఇప్పుడు, మేము ఈ బేస్ క్లాస్ యొక్క “~B()” డిస్ట్రక్టర్‌ను కూడా సృష్టిస్తాము, దీనిలో మేము మళ్లీ “కౌట్”ని ఉపయోగిస్తాము. అప్పుడు, మేము 'B' బేస్ క్లాస్ నుండి ఉత్పన్నమైన తరగతి అయిన 'D' క్లాస్‌ని సృష్టించి, ఇక్కడ 'పబ్లిక్'ని ఉంచుతాము. ఈ “పబ్లిక్” లోపల, మేము వరుసగా “D()” మరియు “~D” పేర్లతో ఉత్పన్నమైన తరగతి యొక్క కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్‌ను సృష్టిస్తాము. రెండూ వాటి లోపల 'కౌట్' కలిగి ఉంటాయి. ఇప్పుడు, మనకు “ప్రధాన ()” ఫంక్షన్ ఉంది. ఈ ఫంక్షన్‌కు కాల్ చేసిన తర్వాత, మేము బేస్ క్లాస్ యొక్క పాయింటర్ ఆబ్జెక్ట్‌ను రూపొందిస్తాము.
అప్పుడు, మేము 'తొలగించు' కీవర్డ్‌ని ఉపయోగిస్తాము మరియు ఇక్కడ 'base_ptr'ని ఉంచుతాము. ఈ సందర్భంలో, బేస్ క్లాస్ యొక్క పాయింటర్ ఆబ్జెక్ట్‌ను కాల్ చేయడం ద్వారా డిస్ట్రక్టర్ యొక్క స్థలం తొలగించబడుతుంది.
కోడ్ 3:
#includeఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి బి
{
ప్రజా :
బి ( )
{
కోట్ << 'బేస్ క్లాస్ యొక్క కన్స్ట్రక్టర్' << endl ;
}
~ బి ( )
{
కోట్ << 'డిస్ట్రక్టర్ ఆఫ్ ది బేస్ క్లాస్' << endl ;
}
} ;
తరగతి డి : ప్రజా బి
{
ప్రజా :
డి ( )
{
కోట్ << 'ఉత్పన్న తరగతి యొక్క కన్స్ట్రక్టర్' << endl ;
}
~డి ( )
{
కోట్ << 'డిస్ట్రక్టర్ ఆఫ్ ది డిరైవ్డ్ క్లాస్' << endl ;
}
} ;
int ప్రధాన ( )
{
బి * బేస్_ptr = కొత్త డి ;
తొలగించు బేస్_ptr ;
}
అవుట్‌పుట్:
ప్రధాన ఫంక్షన్‌లో “B” తరగతిని సూచించే పాయింటర్ ఆబ్జెక్ట్‌ని ఉపయోగిస్తుందని ఫలితం చూపిస్తుంది. అందువలన, ఇది మొదట 'B' తరగతి యొక్క 'కన్స్ట్రక్టర్()' అని పిలుస్తుంది. అప్పుడు, అది 'D' క్లాస్ యొక్క 'కన్స్ట్రక్టర్()' అని పిలుస్తుంది. 'B' మరియు 'D' తరగతుల డిస్ట్రక్టర్లచే పట్టుకున్న పాయింటర్ ఆబ్జెక్ట్ తొలగించబడుతుంది. ప్రోగ్రామ్‌లోని “D” క్లాస్ డిస్ట్రక్టర్‌ని ఇన్వోక్ చేయకుండా, “B” క్లాస్ పాయింటర్ “B” క్లాస్ డిస్ట్రక్టర్‌ను మాత్రమే తొలగిస్తుంది. ఫలితంగా, ప్రోగ్రామ్ మెమరీ పాడైంది.
ముగింపు
మేము C++ ప్రోగ్రామింగ్‌లో “వర్చువల్ కన్‌స్ట్రక్షన్” కాన్సెప్ట్ గురించి చర్చించాము. మేము C++లో వర్చువల్ కన్స్ట్రక్టర్ని సృష్టించలేమని అన్వేషించాము, కానీ మేము మా కోడ్‌లలో వర్చువల్ డిస్ట్రక్టర్‌ని సృష్టించవచ్చు. ఇక్కడ, మేము C++ ప్రోగ్రామింగ్‌లో వర్చువల్ కన్స్ట్రక్టర్ను సృష్టించినప్పుడు ఏమి జరిగిందో మరియు మా కోడ్‌లలో వర్చువల్ డిస్ట్రక్టర్ యొక్క పనితీరును చూపించాము. కన్స్ట్రక్టర్ వర్చువల్ కాదని మేము తెలుసుకున్నాము, కానీ మేము మా తరగతిలో వర్చువల్ డిస్ట్రక్టర్‌ను రూపొందించగలము. మేము కొన్ని ఉదాహరణలను ప్రదర్శించాము మరియు ఈ గైడ్‌లో ఈ కోడ్‌లను పూర్తిగా వివరించాము.