వారసత్వంతో పాటు, C++లో కన్‌స్ట్రక్టర్‌లు కూడా అవసరం. ఎ నిర్మాణకర్త ఆబ్జెక్ట్ యొక్క లక్షణాలను ప్రారంభించేందుకు మిమ్మల్ని అనుమతించే ఏకైక సభ్యుని ఫంక్షన్. ఒక వారసత్వ నిర్మాణకర్త ఉత్పన్నమైన తరగతి వారసత్వంగా పొందిన బేస్ క్లాస్ మరియు డెరైవ్డ్ క్లాస్ ఆబ్జెక్ట్‌లు రెండింటినీ ప్రారంభించేందుకు ఉపయోగించే కన్స్ట్రక్టర్. ది వారసత్వ నిర్మాణకర్త వారసత్వంగా వచ్చిన బేస్ క్లాస్ మెంబర్‌లు మరియు డెరైవ్డ్ క్లాస్ మెంబర్‌లు రెండింటినీ ప్రారంభించడం బాధ్యత. దీన్ని సాధించడానికి, కన్స్ట్రక్టర్ బేస్ క్లాస్ యొక్క కన్స్ట్రక్టర్‌ను ఆహ్వానిస్తాడు, బేస్ క్లాస్ నుండి వారసత్వంగా పొందిన వారితో సహా ఉత్పన్నమైన తరగతిలోని సభ్యులందరూ సరిగ్గా ప్రారంభించబడ్డారని నిర్ధారిస్తారు.
బేస్ క్లాస్ యొక్క కన్స్ట్రక్టర్‌ను ప్రారంభించడం ద్వారా మరియు అవసరమైన పారామితులను పాస్ చేయడం ద్వారా, ది వారసత్వ నిర్మాణకర్త బేస్ క్లాస్ సభ్యులను ప్రారంభిస్తుంది. ఇది ఉపయోగించి సాధించబడుతుంది 'బేస్ క్లాస్(ఆర్గ్స్)' కన్స్ట్రక్టర్‌లో ప్రారంభ జాబితా. ఉత్పన్నమైన తరగతికి సంబంధించిన మరిన్ని సూచనలు కన్స్ట్రక్టర్ బాడీలో అందించబడ్డాయి.
కోసం వాక్యనిర్మాణం వారసత్వంగా C++లో ఒక తరగతి:
తరగతి డెరైవ్డ్ క్లాస్ : యాక్సెస్ స్పెసిఫైయర్ బేస్ క్లాస్ {
// తరగతి సభ్యులు
} ;
ఈ సందర్భంలో ఏర్పడిన కొత్త తరగతి, 'ఉత్పన్న తరగతి', నుండి వారసత్వంగా ఉంటుంది 'బేస్ క్లాస్'. వారసత్వంగా వచ్చిన సభ్యులకు యాక్సెస్ స్థాయిని దీని ద్వారా పేర్కొనబడింది యాక్సెస్ స్పెసిఫైయర్'. C++ మూడు రకాల యాక్సెస్ స్పెసిఫైయర్‌లను ఉపయోగిస్తుంది, అవి 'పబ్లిక్', 'ప్రైవేట్', మరియు 'రక్షిత' . ఆ పదం 'ప్రజా' ఉత్పన్నమైన తరగతికి బేస్ క్లాస్ పబ్లిక్ మెంబర్‌లకు యాక్సెస్ ఉందని సూచిస్తుంది. దీని ప్రకారం, ఉత్పన్నమైన తరగతికి బేస్ క్లాస్ సభ్యులకు యాక్సెస్ లేదు 'ప్రైవేట్' స్పెసిఫైయర్. ఉత్పన్నమైన తరగతి వారి పిల్లల తరగతుల ద్వారా వారసత్వంగా పొందగలిగే రక్షిత బేస్ క్లాస్ సభ్యులకు ప్రాప్యతను కలిగి ఉంది 'రక్షిత' స్పెసిఫైయర్.
C++లో వారసత్వానికి ఉదాహరణ
కింది ఉదాహరణ అమలును చూపుతుంది వారసత్వం C++లో:
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి జంతువు {
ప్రజా :
శూన్యం తినండి ( ) {
కోట్ << 'నేను తినగలను!' << endl ;
}
శూన్యం నిద్ర ( ) {
కోట్ << 'నేను పడుకోగలను!' << endl ;
}
} ;
తరగతి పిల్లి : ప్రజా జంతువు {
ప్రజా :
శూన్యం మిఅవ్ ( ) {
కోట్ << 'నేను మియావ్ చేయగలను!' << endl ;
}
} ;
int ప్రధాన ( ) {
పిల్లి పిల్లి 1 ;
పిల్లి1. తినండి ( ) ;
పిల్లి1. నిద్ర ( ) ;
పిల్లి1. మిఅవ్ ( ) ;
తిరిగి 0 ;
}
ఇచ్చిన కోడ్ రెండు తరగతులను నిర్వచిస్తుంది, 'జంతువు' మరియు 'పిల్లి' , ఎక్కడ 'పిల్లి' నుండి ఉద్భవించింది 'జంతువు' . రెండు తరగతులు వంటి కొన్ని సభ్యుల విధులు ఉన్నాయి 'తిను', 'నిద్ర' , మరియు 'మిఅవ్' . ప్రధాన విధి తరగతి యొక్క వస్తువును సృష్టిస్తుంది 'పిల్లి' మరియు కాల్స్ వారసత్వంగా తరగతి నుండి విధులు 'జంతువు' అలాగే తరగతి యొక్క నిర్దిష్ట విధి 'పిల్లి' , ఏది 'మిఅవ్' . ప్రోగ్రామ్ కన్సోల్‌కు వచనాన్ని అవుట్‌పుట్ చేస్తుంది, పిల్లి తినవచ్చు, నిద్రపోవచ్చు మరియు మియావ్ చేయగలదని సూచిస్తుంది.
అవుట్‌పుట్
క్లాస్ ఉత్పన్నమైనప్పుడు, అన్ని బేస్ క్లాస్ మెంబర్ వేరియబుల్స్ మరియు మెంబర్ ఫంక్షన్‌లు డెరైవ్డ్ క్లాస్‌కి బదిలీ చేయబడతాయి. ది వారసత్వంగా డెరైవ్డ్ క్లాస్‌లో సభ్యుల యాక్సెసిబిలిటీ యాక్సెస్ స్పెసిఫైయర్ ద్వారా నిర్ణయించబడుతుంది. ఉత్పన్నమైన తరగతి ఇప్పటికే ఉన్న వాటి కోసం కొత్త ఫీచర్‌లను కూడా భర్తీ చేయవచ్చు. ఇది బేస్ క్లాస్ పద్ధతుల కోసం కొత్త అమలులను జోడించగలదు మరియు కొత్త సభ్యుల ఫంక్షన్‌లు మరియు వేరియబుల్‌లను జోడించగలదు.
అని గుర్తుంచుకోవడం చాలా ముఖ్యం వారసత్వ నిర్మాణకర్త బేస్ క్లాస్‌లో డిఫాల్ట్ కన్స్ట్రక్టర్ ఉంటే లేదా అది అందుబాటులో లేకుంటే అవసరమైన పారామితులతో బేస్ క్లాస్ కన్‌స్ట్రక్టర్‌ని స్పష్టంగా కాల్ చేయడానికి తప్పనిసరిగా ఉపయోగించాలి.
ముగింపు
యొక్క బలమైన లక్షణం వారసత్వం C++లో ఇతర వాటి నుండి లక్షణాలు మరియు చర్యలను వారసత్వంగా పొందడం ద్వారా తరగతులు కోడ్‌ని మళ్లీ ఉపయోగించేందుకు అనుమతిస్తుంది. C++ యొక్క ఉపయోగకరమైన ఫీచర్ వారసత్వ నిర్మాణకర్త మూల తరగతి యొక్క లక్షణాలు, పద్ధతులు మరియు డేటా సభ్యులను వారసత్వంగా పొందేందుకు ఉత్పన్నమైన తరగతులను అనుమతిస్తుంది. బేస్ క్లాస్ కన్‌స్ట్రక్టర్‌ల కోసం ఇనిషియలైజేషన్ జాబితాను జోడించడంతో, ఇది ప్రామాణిక కన్స్ట్రక్టర్ వలె అదే వాక్యనిర్మాణాన్ని ఉపయోగించి నిర్వచించబడుతుంది. C++ ప్రోగ్రామర్లు కోడ్ డూప్లికేషన్‌ను తగ్గించవచ్చు మరియు కోడ్ నిర్మాణాన్ని ఉపయోగించడం ద్వారా మెరుగుపరచవచ్చు వారసత్వ నిర్మాణకర్త . ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌లో సంక్లిష్టమైన తరగతి సోపానక్రమాలను సృష్టించడానికి, ఇది ఒక ముఖ్యమైన సాధనం.