OOP, కన్స్ట్రక్టర్లు మరియు డిస్ట్రక్టర్ల గురించి మాట్లాడిన తర్వాత, ఇప్పుడు వర్చువల్ డిస్ట్రక్టర్ల గురించి మాట్లాడుకుందాం. వర్చువల్ డిస్ట్రక్టర్లు, పేరు పేర్కొన్నట్లుగా, వస్తువును నాశనం చేస్తాయి. మాకు బేస్ క్లాస్ మరియు బేస్ క్లాస్ నుండి ఉత్పన్నమైన క్లాస్ ఉన్నాయి. రెండు తరగతులకు వాటి కన్స్ట్రక్టర్లు మరియు డిస్ట్రక్టర్లు ఉన్నాయి. వర్చువల్ డిస్ట్రక్టర్ 'వర్చువల్' కీవర్డ్‌తో బేస్ క్లాస్ పాయింటర్‌ని ఉపయోగించి ఉత్పన్నమైన క్లాస్ ఆబ్జెక్ట్‌లను తొలగిస్తున్నప్పుడు డెరైవ్డ్ క్లాస్ ఆబ్జెక్ట్ ద్వారా కేటాయించబడే జ్ఞాపకాలను ఫ్రీ చేస్తుంది.
మనం వర్చువల్ డిస్ట్రక్టర్‌ను ఎందుకు ఉపయోగిస్తాము?
క్లాస్ మెంబర్ ఫంక్షన్‌ల అమలు పూర్తయినప్పుడు లేదా మెయిన్() పద్ధతి యొక్క అమలు ముగియబోతున్నప్పుడు, ఆబ్జెక్ట్ సృష్టి సమయంలో కేటాయించబడిన మెమరీని ఖాళీ చేయడానికి డిస్ట్రక్టర్ స్వయంచాలకంగా పిలువబడుతుంది. ఇప్పుడు, మనం వర్చువల్ డిస్ట్రక్టర్‌ని ఎందుకు ఉపయోగిస్తాము? ఉత్పన్నమైన తరగతిని సూచించే బేస్ క్లాస్ తొలగించబడినప్పుడు, పాయింటర్ (*) ఇక్కడ ఉపయోగించబడుతుంది. బేస్ క్లాస్ డిస్ట్రక్టర్ ఈ ప్రక్రియలో మాత్రమే పిలువబడుతుంది. ఉత్పన్నమైన క్లాస్ డిస్ట్రక్టర్ అని పిలవబడదు, ఇది సమస్యలకు దారి తీస్తుంది. వాటిలో మెమరీ లీకేజీ సమస్య ఒకటి. ఈ సమస్యను నివారించడానికి మరియు మా కోడ్‌ను సురక్షితంగా ఉంచడానికి, బేస్ క్లాస్ డిస్ట్రక్టర్‌ని తొలగించడం ద్వారా ఆబ్జెక్ట్‌ల సృష్టి సమయంలో కేటాయించిన మెమరీ స్థలాన్ని ఖాళీ చేయడానికి మేము వస్తువులను వాస్తవంగా నాశనం చేస్తాము.
వర్చువల్ డిస్ట్రక్టర్ లేకుండా C++ ప్రాథమిక ఉదాహరణ
పాయింటర్‌ను తొలగించే సాధారణ ప్రోగ్రామ్‌తో వర్చువల్ డిస్ట్రక్టర్ లేకుండా ప్రోగ్రామ్ ఎలా పనిచేస్తుందో చూద్దాం.
కోడ్:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
తరగతి పేరెంట్_క్లాస్0
{
ప్రజా :
పేరెంట్_క్లాస్0 ( )
{ కోట్ << 'పేరెంట్ క్లాస్ కన్స్ట్రక్టర్' << endl ; }
~తల్లిదండ్రుల_తరగతి0 ( )
{ కోట్ << 'పేరెంట్ క్లాస్ డిస్ట్రక్టర్' << endl ; }
} ;
తరగతి చైల్డ్_1 : పబ్లిక్ పేరెంట్_క్లాస్0
{
ప్రజా :
బాల_1 ( )
{ కోట్ << 'చైల్డ్ క్లాస్ కన్స్ట్రక్టర్' << endl ; }
~పిల్ల_1 ( )
{ కోట్ << 'చైల్డ్ క్లాస్ డిస్ట్రక్టర్' << endl ; }
} ;
int ప్రధాన ( )
{
పేరెంట్_క్లాస్0 * పాయింటర్ = కొత్త బిడ్డ_1 ( ) ;
పాయింటర్‌ని తొలగించండి ;
తిరిగి 0 ;
}
వర్చువల్ డిస్ట్రక్టర్ లేకుండా కోడ్ ఎలా అమలు చేయబడుతుందో ఈ కోడ్ వివరిస్తుంది. అన్నింటిలో మొదటిది, పేరెంట్ క్లాస్ అయిన 'Parent_Class0' పేరుతో ఒక తరగతిని సృష్టించండి. ఈ తరగతి లోపల, కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్‌ను సృష్టించండి. మనకు తెలిసినట్లుగా, కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్ తరగతికి సమానమైన పేరు పెట్టారు. డిస్ట్రక్టర్ కన్స్ట్రక్టర్ మాదిరిగానే సూచించబడుతుంది, అయితే ఇది కన్స్ట్రక్టర్ నుండి వేరు చేసే గుర్తు (~)ని కలిగి ఉంటుంది. కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్ లోపల, “కౌట్<<” ఉపయోగించి సందేశాన్ని ప్రింట్ చేయండి. ఇప్పుడు, 'Child_1' అనే మరొక తరగతిని సృష్టించండి. ఈ తరగతి పేరెంట్ క్లాస్, “Parent_Class0” నుండి తీసుకోబడింది. ఉత్పన్నమైన తరగతి దాని కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్‌ను కలిగి ఉంది, అది అవుట్‌పుట్ స్క్రీన్‌పై ముద్రించడానికి సందేశాన్ని కలిగి ఉంటుంది.
ప్రధాన() పద్ధతిలో, మేము 'Parent_Class0' యొక్క ఉదాహరణను సృష్టించి, దానికి ఉత్పన్నమైన తరగతిని కేటాయిస్తాము. ఈ సందర్భంలో గుర్తుంచుకోవలసిన కీలకమైన అంశం ఏమిటంటే, పేరెంట్ క్లాస్‌ని తిరిగి పొందడానికి మేము పాయింటర్‌ను ఉపయోగిస్తాము. ఇది పేరెంట్ క్లాస్ లోపలికి వెళ్ళినప్పుడు, అది పేరెంట్ క్లాస్ కన్‌స్ట్రక్టర్‌ని ఎగ్జిక్యూట్ చేస్తుంది. అప్పుడు, అది చైల్డ్ క్లాస్‌కి వెళ్లి దాని కన్స్ట్రక్టర్‌ను అమలు చేస్తుంది. చైల్డ్ క్లాస్ డిస్ట్రక్టర్‌ని ఎగ్జిక్యూట్ చేసే ముందు, అది పేరెంట్ క్లాస్ డిస్ట్రక్టర్‌ని ఎగ్జిక్యూట్ చేయాలి. కంపైలర్ పేరెంట్ క్లాస్ డిస్ట్రక్టర్‌ని ఎగ్జిక్యూట్ చేస్తుంది మరియు చైల్డ్ క్లాస్ డిస్ట్రక్టర్‌ని ఎగ్జిక్యూట్ చేయకుండా క్లాస్‌ని ముగించింది. అది సమస్య; ఇది పిల్లల తరగతి జ్ఞాపకశక్తిని ఖాళీ చేయదు. ఇది పేరెంట్ క్లాస్ కన్స్ట్రక్టర్, చైల్డ్ క్లాస్ కన్స్ట్రక్టర్ మరియు పేరెంట్ క్లాస్ డిస్ట్రక్టర్‌ని సూచిస్తుంది. పిల్లల తరగతిని నాశనం చేసే వ్యక్తి అమలు చేయబడలేదని ఇది చూపిస్తుంది. ఈ అమలు తర్వాత, మేము ప్రధాన () ఫంక్షన్‌లోని పాయింటర్‌ను తొలగిస్తాము.
అవుట్‌పుట్:
వర్చువల్ డిస్ట్రక్టర్‌తో C++ ఉదాహరణ
వర్చువల్ డిస్ట్రక్టర్‌తో మరియు వర్చువల్ డిస్ట్రక్టర్ లేకుండా ఎలా పనిచేస్తుందో వేరు చేయడానికి ఒక సాధారణ కోడ్‌తో వర్చువల్ డిస్ట్రక్టర్ గురించి చర్చిద్దాం.
కోడ్:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
తరగతి పేరెంట్_క్లాస్0
{
ప్రజా :
పేరెంట్_క్లాస్0 ( )
{ కోట్ << 'పేరెంట్ క్లాస్ కన్స్ట్రక్టర్' << endl ; }
వర్చువల్ ~Parent_Class0 ( )
{ కోట్ << 'పేరెంట్ క్లాస్ డిస్ట్రక్టర్' << endl ; }
} ;
తరగతి చైల్డ్_1 : పబ్లిక్ పేరెంట్_క్లాస్0
{
ప్రజా :
బాల_1 ( )
{ కోట్ << 'చైల్డ్ క్లాస్ కన్స్ట్రక్టర్' << endl ; }
వర్చువల్ ~చైల్డ్_1 ( )
{ కోట్ << 'చైల్డ్ క్లాస్ డిస్ట్రక్టర్' << endl ; }
} ;
int ప్రధాన ( )
{
పేరెంట్_క్లాస్0 * పాయింటర్ = కొత్త బిడ్డ_1 ( ) ;
పాయింటర్‌ని తొలగించండి ;
తిరిగి 0 ;
}
మొదటి ప్రోగ్రామ్ వర్చువల్ డిస్ట్రక్టర్ లేకుండా మనం ఎదుర్కొంటున్న సమస్యను వివరించింది. ఇప్పుడు, ఈ కోడ్ వర్చువల్ డిస్ట్రక్టర్ ఉపయోగించి ఆ సమస్యను పరిష్కరిస్తుంది. ముందుగా, మొదటి కోడ్‌ను కాపీ చేసి, ఈ ప్రోగ్రామ్‌లో రెండు ప్రదేశాలలో ఒక కీవర్డ్‌ని జోడించండి. ఆ పదం 'వర్చువల్'. పేరెంట్ క్లాస్ డిస్ట్రక్టర్, “Parent_Class0”తో ఈ పదాన్ని చొప్పించండి. అదేవిధంగా, పేరెంట్ క్లాస్ నుండి ఉద్భవించిన 'Child_1' అయిన చైల్డ్ క్లాస్ డిస్ట్రక్టర్‌తో దీన్ని పేర్కొనండి. ఈ “వర్చువల్” కీవర్డ్ కొద్దిగా మార్పు చేస్తుంది మరియు ఇది మొదట “Child_1” చైల్డ్ క్లాస్ డిస్ట్రక్టర్‌ని అమలు చేస్తుంది. అప్పుడు, ఇది పేరెంట్ క్లాస్, “Parent_Class0” యొక్క డిస్ట్రక్టర్‌ను అమలు చేస్తుంది. వర్చువల్ డిస్ట్రక్టర్ లేకుండా పనిచేసే విధంగానే మిగిలిన ప్రోగ్రామ్ కూడా పనిచేస్తుంది. ఈ చిన్న కోడ్ ముక్కను జోడించడం ద్వారా, మన మెమరీని లీకేజ్ నుండి కాపాడుకోవచ్చు. ఇప్పుడు, ఇది కన్సోల్‌లో నాలుగు సందేశాలను ప్రదర్శిస్తుంది. మొదట, పేరెంట్ క్లాస్ యొక్క కన్స్ట్రక్టర్, తర్వాత చైల్డ్ క్లాస్ యొక్క కన్స్ట్రక్టర్, చైల్డ్ క్లాస్ డిస్ట్రక్టర్ మరియు పేరెంట్ క్లాస్ డిస్ట్రక్టర్. చివరికి, మేము ప్రధాన () పద్ధతిలో పాయింటర్‌ను తొలగిస్తాము.
అవుట్‌పుట్:
C++ ప్యూర్ వర్చువల్ డిస్ట్రక్టర్ యొక్క ఉదాహరణ
ఈ కోడ్‌లో, మేము స్వచ్ఛమైన వర్చువల్ డిస్ట్రక్టర్ గురించి మాట్లాడుతాము, ఇది ఎలా పని చేస్తుంది మరియు ఇది వర్చువల్ డిస్ట్రక్టర్ నుండి ఎలా భిన్నంగా ఉంటుంది.
కోడ్:
#తరగతి తల్లిదండ్రులు_0 {
ప్రజా :
వర్చువల్ ~పేరెంట్_0 ( ) = 0 ;
} ;
తల్లిదండ్రులు_0 :: ~తల్లిదండ్రులు_0 ( )
{
std :: కోట్ << 'హలో ఐ యామ్ ప్యూర్ డిస్ట్రక్టర్. యు కాల్డ్ మి!' ;
}
తరగతి చైల్డ్_0 : పబ్లిక్ పేరెంట్_0 {
ప్రజా :
~పిల్ల_0 ( ) { std :: కోట్ << 'ఉత్పన్నమైన డిస్ట్రక్టర్ ఇక్కడ ఉంది \n ' ; }
} ;
int ప్రధాన ( )
{
తల్లిదండ్రులు_0 * ptr_0 = కొత్త చైల్డ్_0 ( ) ;
ptr_0ని తొలగించండి ;
తిరిగి 0 ;
}
పేరెంట్ క్లాస్ 'Parent_0' కోడ్ యొక్క మొదటి దశలో సృష్టించబడింది. దాని లోపల, వర్చువల్ పేరెంట్ డిస్ట్రక్టర్‌ని సృష్టించి, దానిని 0తో కేటాయించండి. ఇది వర్చువల్ డిస్ట్రక్టర్‌ను ప్యూర్ వర్చువల్ డిస్ట్రక్టర్‌గా సెట్ చేస్తుంది అంటే పేరెంట్ క్లాస్ ఇప్పుడు అబ్‌స్ట్రాక్ట్‌గా ఉంది మరియు మేము ఈ క్లాస్ యొక్క ఇన్‌స్టాన్స్‌లను సృష్టించలేము. పేరెంట్ క్లాస్ 'Parent_0' వెలుపల, డిస్ట్రక్టర్లను మరియు std::coutని నిర్వచించండి. std::coutని ఉపయోగించడం ద్వారా అవసరమైన వచనం చూపబడుతుంది. ఆపై, పేరెంట్ క్లాస్ నుండి “Child_0” క్లాస్‌ని పొందండి మరియు దాని డిస్ట్రక్టర్‌ని నిర్వచించండి. డిస్ట్రక్టర్ లోపల, సందేశాన్ని ప్రింట్ చేయండి. ప్రధాన() ఫంక్షన్‌లో, పేరెంట్ క్లాస్ యొక్క పాయింటర్‌ను సృష్టించండి మరియు దానికి చైల్డ్ క్లాస్‌ను కేటాయించండి.
కంపైలర్ పేరెంట్ క్లాస్ “పేరెంట్_0”కి వెళుతుంది. పాయింటర్ సృష్టించబడినప్పుడు, దాని కన్స్ట్రక్టర్ స్వయంచాలకంగా పిలువబడుతుంది. అప్పుడు, కంపైలర్ దాని కన్స్ట్రక్టర్‌ను పిలవడానికి చైల్డ్ క్లాస్‌లోకి వెళుతుంది. కన్స్ట్రక్టర్ విజయవంతంగా అమలు చేయబడిన తర్వాత, ఇది చైల్డ్ క్లాస్ “చైల్డ్_0” యొక్క డిస్ట్రక్టర్‌ను అమలు చేస్తుంది. అప్పుడు, ఇది పేరెంట్ క్లాస్ యొక్క డిస్ట్రక్టర్‌ను అమలు చేస్తుంది. ఈ విధంగా, మనం స్వచ్ఛమైన వర్చువల్ డిస్ట్రక్టర్‌ను తయారు చేయవచ్చు. ఈ పద్ధతిని ఉపయోగించడం ద్వారా, పేరెంట్ క్లాస్ అబ్‌స్ట్రాక్ట్‌గా మారడం వలన దానిని ఉపయోగించుకోవడం ప్రోత్సహించబడదు. ఎక్కువగా ఉపయోగించే పద్దతి వర్చువల్ డిస్ట్రక్టర్ మరియు ఇది మంచి అభ్యాసం.
అవుట్‌పుట్:
ముగింపు
OOP కాన్సెప్ట్ నుండి కన్స్ట్రక్టర్లు మరియు డిస్ట్రక్టర్ల వైపు వెళ్లడం వరకు వర్చువల్ డిస్ట్రక్టర్ గురించి మేము తెలుసుకున్నాము. వీటన్నింటినీ వివరించిన తర్వాత, మేము కోడింగ్ ఉదాహరణలు మరియు స్వచ్ఛమైన వర్చువల్ డిస్ట్రక్టర్‌తో వర్చువల్ డిస్ట్రక్టర్ గురించి వివరంగా చర్చించాము. వర్చువల్ డిస్ట్రక్టర్ గురించి వివరించే ముందు, మనం కన్స్ట్రక్టర్లు, డిస్ట్రక్టర్లు మరియు వారసత్వం గురించి తెలుసుకోవాలి. వారసత్వంలో, మేము మాతృ తరగతి నుండి తరగతులను వారసత్వంగా పొందుతాము. పిల్లల తరగతులు ఒకటి కంటే ఎక్కువ ఉండవచ్చు కానీ పేరెంట్ క్లాస్ ఒకటి మాత్రమే. వర్చువల్ డిస్ట్రక్టర్లు మరియు ప్యూర్ వర్చువల్ డిస్ట్రక్టర్లు మెమొరీ లీకేజ్ నుండి సేవ్ చేయడానికి వారసత్వంగా వర్తింపజేయబడతాయి. ప్రాథమిక ఉదాహరణ నుండి అధునాతన ఉదాహరణ వరకు, ఉత్పన్నమైన తరగతి యొక్క మెమరీని ఉపయోగించడం మరియు వర్చువల్‌గా నాశనం చేయడం ప్రారంభించడానికి మీరు తెలుసుకోవలసిన ప్రతిదాన్ని మేము కవర్ చేసాము.