ఈ వ్యాసంలో, మేము C ++ ప్రోగ్రామింగ్‌లో వారసత్వ భావన గురించి చర్చించబోతున్నాం. మేము C ++ లో ఫ్రెండ్ ఫంక్షన్ భావనను పని ఉదాహరణలతో వివరిస్తాము.
వారసత్వం ఎందుకు?
వారసత్వం కొత్త తరగతి లేదా మరొక తరగతి లేదా బేస్ తరగతి నుండి ఉత్పన్నమైన తరగతిని సృష్టించడానికి అనుమతిస్తుంది. ఉత్పన్నమైన తరగతి లేదా పిల్లల తరగతి మాతృ తరగతి లేదా బేస్ తరగతి యొక్క అన్ని లక్షణాలను కలిగి ఉంటుంది. మేము వారసత్వ సహాయంతో కోడ్‌ని తిరిగి ఉపయోగించవచ్చు.
వారసత్వ రకం
వివిధ రకాల వారసత్వాలు ఉన్నాయి:
- సాధారణ/ఒకే వారసత్వం
- క్రమానుగత వారసత్వం
- బహుళస్థాయి వారసత్వం
- బహుళ వారసత్వం
ఈ వ్యాసంలో, మేము సాధారణ/ఒకే వారసత్వాన్ని మాత్రమే పరిగణించబోతున్నాం.
ఉదాహరణ 1:
ఇప్పుడు, C ++ లో వారసత్వ భావనను అర్థం చేసుకోవడానికి ఒక ఉదాహరణ కార్యక్రమాన్ని చూద్దాం. మేము ఒక బేస్ క్లాస్‌ని నిర్వచించాము మరియు దాని నుండి మరొక తరగతిని పొందాము. అందువల్ల, ఉత్పన్నమైన తరగతి బేస్ తరగతి నుండి లక్షణాలను (సభ్యులు మరియు విధులు) కలిగి ఉంటుంది.
#చేర్చండినేమ్స్పేస్ std ఉపయోగించి;
తరగతి బేస్_ తరగతి
{
ప్రజా:
inti;
శూన్యంప్రదర్శన()
{
ఖరీదు<< 'డిస్‌ప్లే ఆఫ్ బేస్ క్లాస్' <<i<<endl;
}
};
తరగతి ఉత్పన్నం_ తరగతి:పబ్లిక్ బేస్_క్లాస్
{
ప్రజా:
శూన్యంచూపించు()
{
ఖరీదు<< 'షో ఆఫ్ డెరివ్డ్ క్లాస్' <<endl;
}
};
intప్రధాన()
{
ఉత్పన్నమైన_ తరగతి డిసి;
dci = 100;
dcప్రదర్శన();
dcచూపించు();
తిరిగి 0;
}
ఉదాహరణ 2:
C ++ లో వారసత్వానికి ఇది మరొక ఉదాహరణ. ఈ ఉదాహరణలో, ఉత్పన్నమైన క్లాస్ ఆబ్జెక్ట్ సృష్టించబడినప్పుడు కన్స్ట్రక్టర్లను ఎలా పిలుస్తారో మనం చూడబోతున్నాం.
మీరు క్రింద చూడగలిగినట్లుగా, మేము రెండు బేస్ క్లాస్ కన్స్ట్రక్టర్లను మరియు మూడు ఉత్పన్నమైన క్లాస్ కన్స్ట్రక్టర్లను నిర్వచించాము. ఉత్పన్నమైన క్లాస్ కన్స్ట్రక్టర్ అని పిలవబడే ముందు బేస్ క్లాస్ కన్స్ట్రక్టర్ మొదటగా పిలువబడుతుందని మీరు దిగువ అవుట్పుట్ నుండి స్పష్టంగా గమనించవచ్చు.
#చేర్చండినేమ్స్పేస్ std ఉపయోగించి;
తరగతి బేస్_ తరగతి
{
ప్రజా:
బేస్_క్లాస్()
{
ఖరీదు<< 'బేస్_క్లాస్ - పారామీటర్లు లేవు' <<endl;
}
బేస్_క్లాస్(intx)
{
ఖరీదు<< 'బేస్_క్లాస్ - పారామీటర్లు:' <<x<<endl;
}
};
తరగతి ఉత్పన్నం_ తరగతి:పబ్లిక్ బేస్_క్లాస్
{
ప్రజా:
ఉత్పన్నమైన_ తరగతి()
{
ఖరీదు<< 'ఉత్పన్నం_ తరగతి - పారామీటర్లు లేవు' <<endl;
}
ఉత్పన్నమైన_ తరగతి(intమరియు)
{
ఖరీదు<< 'ఉత్పన్నం_ తరగతి - పారామీటర్లు:' <<మరియు<<endl;
}
ఉత్పన్నమైన_ తరగతి(intx,intమరియు):బేస్_క్లాస్(x)
{
ఖరీదు<< 'పరమ్ ఆఫ్ డెరివ్డ్_క్లాస్:' <<మరియు<<endl;
}
};
intప్రధాన()
{
ఉత్పన్నమైన_ తరగతి డి(7,19);
}
ఉదాహరణ 3:
ఈ ఉదాహరణలో, ఉత్పన్నమైన తరగతి వస్తువులను ఎలా ఉపయోగించవచ్చో మనం చూడబోతున్నాం.
మీరు చూడగలిగినట్లుగా, రెండు తరగతులు నిర్వచించబడ్డాయి: దీర్ఘచతురస్రం_క్లాస్ మరియు క్యూబ్_క్లాస్. దీర్ఘచతురస్రం_క్లాస్ అనేది బేస్ క్లాస్, దీని నుండి ఉత్పన్నమైన క్లాస్, అంటే క్యూబ్_క్లాస్ ఉద్భవించింది. అందువల్ల, మేము దీర్ఘచతురస్రం_క్లాస్ నుండి క్యూబ్_క్లాస్ వరకు లక్షణాలను వారసత్వంగా పొందుతున్నాము.
అలాగే, మేము పబ్లిక్ యాక్సెస్ నియంత్రణతో క్యూబ్_క్లాస్‌ను వారసత్వంగా పొందుతున్నామని మీరు గమనించవచ్చు. దీని అర్థం, ఉత్పన్నమైన తరగతి బేస్ క్లాస్ యొక్క ప్రైవేట్ కాని సభ్యులందరినీ యాక్సెస్ చేయగలదు.
మేము ఉత్పన్నమైన తరగతి యొక్క వస్తువును ప్రకటించాము, ఆపై బేస్ క్లాస్ నుండి పద్ధతులను పిలుస్తాము, అనగా సెట్‌లెంగ్త్ () మరియు సెట్‌బ్రెడ్ ().
#చేర్చండినేమ్స్పేస్ std ఉపయోగించి;
తరగతి దీర్ఘచతురస్రం_ తరగతి
{
ప్రైవేట్:
intపొడవు;
intవెడల్పు;
ప్రజా:
దీర్ఘచతురస్రం_ తరగతి();
దీర్ఘచతురస్రం_ తరగతి(intది,intబి);
దీర్ఘచతురస్రం_ తరగతి(దీర్ఘచతురస్రం_ తరగతి&ఆర్);
intపొడవు పొందండి()
{
తిరిగిపొడవు;
}
intgetBreadth()
{
తిరిగివెడల్పు;
}
శూన్యంసెట్ పొడవు(intది);
శూన్యంసెట్‌బ్రెడ్(intబి);
intప్రాంతం();
};
క్లాస్ క్యూబ్_క్లాస్:ప్రజా దీర్ఘచతురస్రం_ తరగతి
{
ప్రైవేట్:
intఎత్తు;
ప్రజా:
క్యూబ్_క్లాస్(inth)
{
ఎత్తు=h;
}
intఎత్తు పొందండి()
{
తిరిగిఎత్తు;
}
శూన్యంసెట్ ఎత్తు(inth)
{
ఎత్తు=h;
}
intవాల్యూమ్()
{
తిరిగిపొడవు పొందండి()*getBreadth()*ఎత్తు;
}
};
దీర్ఘచతురస్రం_ తరగతి::దీర్ఘచతురస్రం_ తరగతి()
{
పొడవు=1;
వెడల్పు=1;
}
దీర్ఘచతురస్రం_ తరగతి::దీర్ఘచతురస్రం_ తరగతి(intది,intబి)
{
పొడవు=ది;
వెడల్పు=బి;
}
దీర్ఘచతురస్రం_ తరగతి::దీర్ఘచతురస్రం_ తరగతి(దీర్ఘచతురస్రం_ తరగతి&ఆర్)
{
పొడవు=ఆర్.పొడవు;
వెడల్పు=ఆర్.వెడల్పు;
}
శూన్యందీర్ఘచతురస్రం_ తరగతి::సెట్ పొడవు(intది)
{
పొడవు=ది;
}
శూన్యందీర్ఘచతురస్రం_ తరగతి::సెట్‌బ్రెడ్(intబి)
{
వెడల్పు=బి;
}
intదీర్ఘచతురస్రం_ తరగతి::ప్రాంతం()
{
తిరిగిపొడవు*వెడల్పు;
}
intప్రధాన()
{
క్యూబ్_క్లాస్ సి(8);
cసెట్ పొడవు(12);
cసెట్‌బ్రెడ్(9);
ఖరీదు<<'వాల్యూమ్'<<cవాల్యూమ్()<<endl;
}
ముగింపు:
ఈ వ్యాసంలో, నేను వారసత్వ భావనను వివరించాను సి ++ . C ++ బహుళ వారసత్వంతో సహా వివిధ రకాల వారసత్వానికి మద్దతు ఇస్తుంది (అనగా, బహుళ బేస్ క్లాస్ లేదా మాతృ తరగతి నుండి వారసత్వ లక్షణాలను పొందడం). అయితే, దీన్ని సులభతరం చేయడానికి, నేను ఇక్కడ ఒకే వారసత్వాన్ని మాత్రమే పరిగణించాను. C ++ ప్రోగ్రామింగ్‌లో మేము వారసత్వాన్ని ఎలా ఉపయోగించవచ్చో మరియు కోడ్‌ని మళ్లీ ఎలా ఉపయోగించవచ్చో వివరించడానికి నేను మూడు పని ఉదాహరణలను చూపించాను. ఇంకా, ఇది C ++ యొక్క చాలా ఉపయోగకరమైన లక్షణం.