సి ++ లో ఫంక్షన్ ఓవర్‌లోడింగ్: మీరు తెలుసుకోవలసినది

సి ++ చాలా ప్రోగ్రామింగ్ భాషలలో ఒకటి, ఇది చాలా సరళమైనది మరియు ఇది ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ యొక్క అనేక లక్షణాలను కూడా కలిగి ఉంటుంది. ఓవర్లోడింగ్ ఈ ప్రోగ్రామింగ్ భాష యొక్క మరొక లక్షణం.ఈ “సి ++ లో ఫంక్షన్ ఓవర్‌లోడింగ్” వ్యాసంలో క్రింది పాయింటర్లు ఉంటాయి.

జావాలో అనుబంధం అంటే ఏమిటి

• సి ++ ఓవర్‌లోడింగ్
• C ++ లో ఓవర్‌లోడింగ్ రకాలు
• C ++ లో ఫంక్షన్ ఓవర్లోడింగ్ అంటే ఏమిటి
  • వాదనల సంఖ్యను మార్చడం ద్వారా
  • వివిధ రకాల వాదనలు కలిగి ఉండటం ద్వారా
• C ++ లో ఫంక్షన్ ఓవర్‌లోడింగ్ యొక్క ప్రయోజనాలు
• C ++ లో ఫంక్షన్ ఓవర్లోడింగ్ యొక్క ప్రతికూలతలు
• ఫంక్షన్ ఓవర్‌లోడింగ్ మరియు అస్పష్టత

సి ++ ఓవర్‌లోడింగ్

మేము ఒక తరగతి యొక్క ఇద్దరు లేదా అంతకంటే ఎక్కువ సభ్యులను ఒకే పేరుతో కలిగి ఉన్నప్పటికీ, సంఖ్య లేదా పారామితులలో భిన్నంగా ఉన్నప్పుడు, దీనిని C ++ ఓవర్‌లోడింగ్ అంటారు. C ++ లో, మేము ఓవర్‌లోడ్ చేయవచ్చు:

• పద్ధతులు,
• కన్స్ట్రక్టర్లు, మరియు
• సూచిక లక్షణాలు

C ++ లో ఓవర్‌లోడింగ్ రకాలు

సి ++ లో ఫంక్షన్ ఓవర్‌లోడింగ్ అంటే ఏమిటి?

C ++ లో ఫంక్షన్ ఓవర్‌లోడింగ్ ఒకే పేరుతో తరగతి యొక్క రెండు లేదా అంతకంటే ఎక్కువ సభ్యుల విధులను కలిగి ఉన్న ప్రక్రియగా నిర్వచించవచ్చు, కాని పారామితులలో భిన్నంగా ఉంటుంది. ఫంక్షన్ ఓవర్‌లోడింగ్‌లో, వివిధ రకాలైన వాదనలు లేదా అవసరానికి అనుగుణంగా వేరే సంఖ్యలో వాదనలు ఉపయోగించడం ద్వారా ఫంక్షన్‌ను పునర్నిర్వచించవచ్చు. ఈ తేడాల ద్వారా మాత్రమే కంపైలర్ రెండు ఓవర్లోడ్ ఫంక్షన్ల మధ్య తేడాను గుర్తించగలదు.

ఫంక్షన్ ఓవర్‌లోడింగ్ యొక్క ప్రధాన ప్రయోజనాల్లో ఒకటి, ఇది ప్రోగ్రామ్ యొక్క రీడబిలిటీని పెంచుతుంది ఎందుకంటే ఒకే చర్య కోసం మేము వేర్వేరు పేర్లను మళ్లీ మళ్లీ ఉపయోగించాల్సిన అవసరం లేదు.

వాదనల సంఖ్యను మార్చడం ద్వారా

ఫంక్షన్ ఓవర్‌లోడింగ్ యొక్క ఈ విధంగా, మేము రెండు ఫంక్షన్లను ఒకే పేర్లతో నిర్వచించాము కాని ఒకే రకమైన వేరే పారామితులను నిర్వచించాము. ఉదాహరణకు, క్రింద పేర్కొన్న ప్రోగ్రామ్‌లో, రెండు మరియు మూడు పూర్ణాంకాల మొత్తాన్ని తిరిగి ఇవ్వడానికి మేము రెండు యాడ్ () ఫంక్షన్లను చేసాము.

// మొదటి ఫంక్షన్ డెఫినిషన్ int add (int a, int b) {cout<< a+b } // second overloaded function definition int add(int a, int b, int c) { cout << a+b+c }

ఇక్కడ జోడించు () ఫంక్షన్ ఓవర్లోడ్ అని చెప్పబడింది, ఎందుకంటే దీనికి రెండు నిర్వచనాలు ఉన్నాయి, ఒకటి రెండు వాదనలను అంగీకరిస్తుంది మరియు మరొకటి మూడు వాదనలను అంగీకరిస్తుంది. ఏ యాడ్ () ఫంక్షన్ అంటారు, ఇది వాదనల సంఖ్యపై ఆధారపడి ఉంటుంది.

int main () {add (10, 20) // add () ను 2 పారామితితో add (10, 20, 30) // sum () 3 పారామితితో పిలుస్తారు called

# నేమ్‌స్పేస్‌ను ఉపయోగించి చేర్చండి std int add (int a, int b) out cout<< a+b <
పై ఉదాహరణలో, మేము దాని వాదనల సంఖ్యను మార్చడం ద్వారా యాడ్ () ఫంక్షన్‌ను ఓవర్‌లోడ్ చేస్తాము. మొదట, మేము రెండు పారామితులతో యాడ్ () ఫంక్షన్‌ను నిర్వచించాము, ఆపై యాడ్ () ఫంక్షన్‌ను మళ్లీ నిర్వచించడం ద్వారా దాన్ని ఓవర్‌లోడ్ చేస్తాము కాని ఈసారి మూడు పారామితులతో.
 వివిధ రకాల వాదనలు కలిగి ఉండటం ద్వారా 
ఈ పద్ధతిలో, మేము ఒకే పేరు మరియు ఒకే సంఖ్యలో పారామితులతో రెండు లేదా అంతకంటే ఎక్కువ ఫంక్షన్లను నిర్వచించాము, అయితే ఈ పారామితుల కోసం ఉపయోగించే డేటా రకం భిన్నంగా ఉంటుంది. ఉదాహరణకు, ఈ ప్రోగ్రామ్‌లో, మనకు మూడు యాడ్ () ఫంక్షన్ ఉంది, మొదటిది రెండు పూర్ణాంక ఆర్గ్యుమెంట్‌లను పొందుతుంది, రెండవది రెండు ఫ్లోట్ ఆర్గ్యుమెంట్‌లను పొందుతుంది మరియు మూడవది రెండు డబుల్ ఆర్గ్యుమెంట్‌లను పొందుతుంది.
# నేమ్‌స్పేస్‌ను ఉపయోగించి చేర్చండి std int add (int x, int y) // మొదటి నిర్వచనం {cout<< x+y << endl return 0 } float add(float a, float b) { cout << a+b << endl return 0 } double add(double x, double y) { cout << x+y << endl return 0 } int main() { add(20, 40) add(23.45f, 34.5f) add(40.24, 20.433) }
పై ఉదాహరణలో, మేము యాడ్ () ఫంక్షన్‌ను మూడుసార్లు నిర్వచించాము. మొదట పూర్ణాంకాలను పారామితులుగా, రెండవది ఫ్లోట్‌ను పారామితులుగా మరియు మూడవది పారామితిగా డబుల్‌ను ఉపయోగించడం. 
ఈ విధంగా మేము యాడ్ () ఫంక్షన్‌ను రెండుసార్లు భర్తీ చేస్తాము.
 C ++ లో ఫంక్షన్ ఓవర్లోడింగ్ యొక్క ప్రయోజనాలు 
మా ప్రోగ్రామ్ యొక్క మెమరీ స్థలం, స్థిరత్వం మరియు చదవడానికి ఆదా చేయడానికి మేము ఫంక్షన్ ఓవర్‌లోడింగ్‌ను ఉపయోగిస్తాము.
యూజ్ ఫంక్షన్ ఓవర్‌లోడింగ్ కాన్సెప్ట్‌తో, ఒకే పేరుతో ఒకటి కంటే ఎక్కువ ఫంక్షన్లను అభివృద్ధి చేయవచ్చు
ఫంక్షన్ ఓవర్‌లోడింగ్ అనేది పాలిమార్ఫిజం యొక్క ప్రవర్తనను చూపిస్తుంది, ఇది వేర్వేరు ప్రవర్తనను పొందడానికి అనుమతిస్తుంది, అయినప్పటికీ ఫంక్షన్ యొక్క అదే పేరును ఉపయోగించి కొంత లింక్ ఉంటుంది.
ఫంక్షన్ ఓవర్‌లోడింగ్ ప్రోగ్రామ్ అమలును వేగవంతం చేస్తుంది.
ఫంక్షన్ పునర్వినియోగం కోడ్ పునర్వినియోగం కోసం మరియు మెమరీని ఆదా చేయడానికి కూడా ఉపయోగించబడుతుంది.
ఇది పరామితి రకం ఆధారంగా తరగతి పద్ధతిని లోడ్ చేయడానికి అనువర్తనానికి సహాయపడుతుంది.
కోడ్ నిర్వహణ సులభం.
 C ++ లో ఫంక్షన్ ఓవర్లోడింగ్ యొక్క ప్రతికూలతలు 
ఫంక్షన్ రివర్షన్ రకంతో మాత్రమే విభిన్నమైన ఫంక్షన్ డిక్లరేషన్లను ఫంక్షన్ ఓవర్‌లోడింగ్ ప్రాసెస్‌తో ఓవర్‌లోడ్ చేయలేము.
సభ్యుల ఫంక్షన్ డిక్లరేషన్లు ఒకే పారామితులతో లేదా ఒకే పేరు రకాలను ఓవర్‌లోడ్ చేయలేవు, వాటిలో దేనినైనా స్టాటిక్ మెంబర్ ఫంక్షన్‌గా ప్రకటించినట్లయితే.
తరగతి XYZ {స్టాటిక్ శూన్య ఫంక్ () శూన్య ఫంక్ () // లోపం}
 ఫంక్షన్ ఓవర్‌లోడింగ్ మరియు అస్పష్టత 
ఓవర్‌లోడ్ చేసిన ఫంక్షన్లలో కంపైలర్ మొదట ఏ ఫంక్షన్‌ను ప్రారంభించాలో నిర్ణయించలేనప్పుడు, ఈ పరిస్థితిని ఫంక్షన్ ఓవర్‌లోడింగ్ అస్పష్టత అంటారు. అస్పష్టత లోపాన్ని చూపిస్తే కంపైలర్ ప్రోగ్రామ్‌ను అమలు చేయదు. ఫంక్షన్ యొక్క కారణాలు ఓవర్లోడింగ్ అస్పష్టత:
మార్పిడి అని టైప్ చేయండి.
డిఫాల్ట్ ఆర్గ్యుమెంట్‌లతో ఫంక్షన్.
పాస్ బై రిఫరెన్స్ తో ఫంక్షన్
 రకం మార్పిడి: 
# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std void function (float) void function (int) void function (float x) {std :: cout<< 'Value of x is : ' <
పై ఉదాహరణ లోపం విసిరింది - “ఓవర్‌లోడ్ చేసిన‘ ఫంక్షన్ (డబుల్) ’కాల్ అస్పష్టంగా ఉంది”. ఫంక్షన్ (3.4) మొదటి ఫంక్షన్‌ను పిలుస్తుంది. ఫంక్షన్ (34) మన అంచనా ప్రకారం రెండవ ఫంక్షన్‌ను పిలుస్తుంది. C ++ లో అన్ని ఫ్లోటింగ్ పాయింట్ స్థిరాంకాలు ఫ్లోట్‌గా కాకుండా డబుల్‌గా పరిగణించబడతాయి. మేము ఫ్లోట్ వేరియబుల్‌ను డబుల్ వేరియబుల్‌కు భర్తీ చేస్తే, ప్రోగ్రామ్ బాగా పనిచేస్తుంది. అందువల్ల మేము దీనిని ఫ్లోట్ నుండి డబుల్ వరకు టైప్ మార్పిడి లోపం అని పిలుస్తాము.
 డిఫాల్ట్ వాదనలతో ఫంక్షన్: 
# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std void function (int) void function (int, int) void function (int x) {std :: cout<< 'Value of x is : ' <
పై ఉదాహరణ “ఓవర్‌లోడ్ చేసిన‘ ఫన్ (పూర్ణాంకం) ’అస్పష్టంగా ఉంది’ అని చెప్పే లోపం ఇస్తుంది, దీనికి కారణం ఫంక్షన్ (int y, int z = 12) ను రెండు విధాలుగా పిలుస్తారు:
ఒక వాదనతో ఫంక్షన్‌ను పిలవడం ద్వారా (మరియు ఇది స్వయంచాలకంగా z = 12 విలువను తీసుకుంటుంది)
ఫంక్షన్‌ను రెండు ఆర్గ్యుమెంట్‌లతో పిలవడం ద్వారా.
మేము ఫంక్షన్ అని పిలిచినప్పుడు: ఫంక్షన్ (12) ఫంక్షన్ (పూర్ణాంకానికి) మరియు ఫంక్షన్ (పూర్ణాంకానికి, పూర్ణాంకానికి) రెండింటి యొక్క స్థితిని పూర్తి చేస్తాము, తద్వారా కంపైలర్ అస్పష్టతకు లోనవుతుంది.
 పాస్ బై రిఫరెన్స్ తో ఫంక్షన్ 
# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std void function (int) void function (int &) void function (int a) {std :: cout<< 'Value of a is : ' < 
పై ప్రోగ్రామ్ “ఓవర్‌లోడ్ చేసిన‘ ఫన్ (పూర్ణాంకం) కాల్ అస్పష్టంగా ఉంది ’అని చెప్పే లోపం ఇస్తుంది. మనం చూసేటప్పుడు మొదటి ఫంక్షన్ ఒక పూర్ణాంక వాదనను తీసుకుంటుంది మరియు రెండవ ఫంక్షన్ రిఫరెన్స్ పరామితిని వాదనగా తీసుకుంటుంది. ఈ సందర్భంలో, కంపైలర్ వినియోగదారుకు ఏ ఫంక్షన్ అవసరమో అర్థం చేసుకోలేకపోతుంది, ఎందుకంటే సరదా (పూర్ణాంకం) మరియు సరదా (పూర్ణాంకానికి) మధ్య వాక్యనిర్మాణ వ్యత్యాసం లేదు కాబట్టి ఇది అస్పష్టత యొక్క లోపాన్ని చిత్రీకరిస్తుంది.
ప్రారంభకులకు ms sql ట్యుటోరియల్
దీనితో, మేము C ++ లో ఈ ఫంక్షన్ ఓవర్‌లోడింగ్ ముగింపుకు వచ్చాము. మీరు మరింత తెలుసుకోవాలనుకుంటే, చూడండి   విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
 మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.