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