సి ++ లో ఆపరేటర్ ఓవర్‌లోడింగ్‌ను ఎలా అమలు చేయాలి?

ఈ వ్యాసంలో ఆపరేటర్ నిర్వహణను సులభతరం చేసే మరో ఆబ్జెక్ట్ ఓరియెంటెడ్ భావనను అన్వేషిస్తాము. అంటే మేము ఆపరేటర్ యొక్క వివరాలను పొందుతాము C ++ లో ఓవర్‌లోడింగ్ . ఈ వ్యాసంలో క్రింది గమనికలు కవర్ చేయబడతాయి,

• C ++ లో ఓవర్‌లోడింగ్
• C ++ లో ఓవర్‌లోడింగ్ రకాలు
• ఆపరేటర్ ఓవర్‌లోడింగ్ ఎందుకు ఉపయోగించబడుతుంది?
• C ++ లో ఆపరేటర్ ఓవర్‌లోడింగ్‌ను అమలు చేస్తోంది
• ఓవర్‌లోడింగ్ విధానాల రకాలు
• యూనిరి ఆపరేటర్లను ఓవర్లోడ్ చేస్తోంది
• బైనరీ ఆపరేటర్లను ఓవర్లోడ్ చేస్తోంది

కాబట్టి, C ++ లో ఆపరేటర్ ఓవర్‌లోడింగ్ పై ఈ కథనంతో ప్రారంభిద్దాం.

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

స్కోప్ ఆపరేటర్ సి ++

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

C ++ లో, మేము ఓవర్‌లోడ్ చేయవచ్చు:

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

ఎందుకంటే ఈ సభ్యులకు పారామితులు మాత్రమే ఉన్నాయి.

C ++ లో ఆపరేటర్ ఓవర్‌లోడింగ్‌పై ఈ కథనంతో కదులుతోంది.

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

• ఫంక్షన్ ఓవర్లోడింగ్
• ఆపరేటర్ ఓవర్‌లోడింగ్

C ++ లో ఆపరేటర్ ఓవర్‌లోడింగ్‌పై ఈ కథనంతో కదులుతోంది.

ఆపరేటర్ ఓవర్‌లోడింగ్ ఎందుకు ఉపయోగించబడుతుంది?

ఆపరేటర్ ఓవర్‌లోడింగ్ తెలియకుండా సి ++ ప్రోగ్రామ్‌లను వ్రాయవచ్చు. అప్పుడు కూడా, ఆపరేటర్ ఆపరేటింగ్ ప్రోగ్రామర్లు ప్రోగ్రాంను సహజంగా చేయడానికి తీవ్రంగా ఉపయోగిస్తారు. ఉదాహరణకి,

మేము ఇలా కోడ్‌ను భర్తీ చేయవచ్చు:

లెక్కింపు = జోడించు (విభజించు (ఎ, బి), గుణించాలి (ఎ, బి))

సమీకరణం కోసం

లెక్కింపు = (a / b) + (a * b)

ఆపరేటర్ ఓవర్‌లోడింగ్ C ++ లోని చాలా మంది ఆపరేటర్లకు కొత్త నిర్వచనాల అభివృద్ధికి సరళమైన మరియు సులభమైన మార్గాన్ని అందిస్తుంది. తగినంత జ్ఞానంతో, ఫంక్షన్ మరియు ఆపరేటర్ ఓవర్‌లోడింగ్ పద్ధతుల యొక్క సృజనాత్మక ఉపయోగం ద్వారా మన స్వంత భాషని దాదాపుగా సృష్టించవచ్చు. మేము కింది మినహా C ++ లోని అన్ని ఆపరేటర్లను ఓవర్లోడ్ చేయవచ్చు:
Ope స్కోప్ ఆపరేటర్ (: :)
Ize సైజు ఆపరేటర్ (సైజుఆఫ్)
● సభ్యుడు సెలెక్టర్ (.)
● సభ్యుల పాయింటర్ సెలెక్టర్ (*)
Ern టెర్నరీ ఆపరేటర్ (? :)

ఆపరేటర్ ఓవర్లోడింగ్ యొక్క సింటాక్స్

సాకెట్ ప్రోగ్రామింగ్ యొక్క ఉపయోగం ఏమిటి

return_type class_name :: ఆపరేటర్ op (ఆర్గ్యుమెంట్_లిస్ట్) {// ఫంక్షన్ బాడీ}

రిటర్న్ రకం అంటే ఫంక్షన్ ద్వారా తిరిగి వచ్చే విలువ. class_name అనేది తరగతి పేరు.

C ++ లో ఆపరేటర్ ఓవర్‌లోడింగ్‌పై ఈ కథనంతో కదులుతోంది.

C ++ లో ఆపరేటర్ ఓవర్‌లోడింగ్‌ను అమలు చేస్తోంది

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

ఆపరేటర్ ఫంక్షన్లు మరియు సాధారణ ఫంక్షన్ల మధ్య తేడా ఏమిటి?

ఆపరేటర్ ఫంక్షన్లు సాధారణ ఫంక్షన్ల మాదిరిగానే ఉంటాయి. ఒకే తేడా ఏమిటంటే, ఆపరేటర్ ఫంక్షన్ పేరు ఎల్లప్పుడూ ఆపరేటర్ కీవర్డ్, తరువాత ఆపరేటర్ యొక్క చిహ్నం మరియు సంబంధిత ఆపరేటర్ ఉపయోగించినప్పుడు ఆపరేటర్ ఫంక్షన్లను పిలుస్తారు.

C ++ లో ఆపరేటర్ ఓవర్‌లోడింగ్‌పై ఈ కథనంతో కదులుతోంది.

ఓవర్‌లోడింగ్ విధానాల రకాలు

ఆపరేటర్ ఓవర్లోడింగ్ మూడు విధానాలను ఉపయోగించడం ద్వారా చేయవచ్చు, అవి

• యూనిరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తోంది.
• బైనరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తోంది.
• ఫ్రెండ్ ఫంక్షన్ ఉపయోగించి బైనరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తోంది.

C ++ లో ఆపరేటర్ ఓవర్‌లోడింగ్‌పై ఈ కథనంతో కదులుతోంది.

ఓవర్‌లోడింగ్ యునరీ ఆపరేటర్

అనామక ‘-‘ ఆపరేటర్‌ని పరిశీలిద్దాం. మైనస్ ఆపరేటర్‌ను యునరీగా ఉపయోగించినప్పుడు దీనికి ఒకే ఒపెరాండ్ అవసరం. ప్రాథమిక డేటా వేరియబుల్‌కు వర్తించినప్పుడు ఈ ఆపరేటర్ ఒపెరాండ్ యొక్క చిహ్నాన్ని మారుస్తుందని మాకు తెలుసు. ఈ ఆపరేటర్‌ను ఓవర్‌లోడ్ ఎలా చేయాలో చూద్దాం, తద్వారా ఇది ఒక వస్తువుకు పూర్ణాంక లేదా ఫ్లోట్ వేరియబుల్‌కు వర్తించే విధంగానే వర్తించబడుతుంది. అనామక మైనస్, ఒక వస్తువుకు వర్తించినప్పుడు, దాని ప్రతి డేటా అంశాలను తగ్గించాలి.

ఉదాహరణ:

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి ఎత్తు {పబ్లిక్: // సభ్యుడు వస్తువులు పూర్ణాంకాలు, అంగుళాలు // వస్తువు విలువను ప్రారంభించడానికి కన్స్ట్రక్టర్ ఎత్తు (int f, int i) {feet = f inch = i} // ఓవర్‌లోడింగ్ (-) ఆపరేటర్‌కు ఎత్తు ఆబ్జెక్ట్ శూన్య ఆపరేటర్- () {అడుగులు - అంగుళం - కౌట్ యొక్క తగ్గింపు // ఆపరేషన్<< 'Feet & Inches after decrement: ' << feet << ' ' ' << inch <
 అవుట్పుట్: 
 వివరణ:  
పై ఉదాహరణలో, ఎత్తు తరగతి యొక్క రెండు వేరియబుల్స్‌లో తగ్గుదల చేయడానికి మేము ‘-’ యునరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తాము. మేము కన్స్ట్రక్టర్కు రెండు పారామితులను పాస్ చేస్తాము మరియు వాటి విలువలను అడుగులు మరియు అంగుళాల వేరియబుల్‌లో సేవ్ చేస్తాము. అప్పుడు మేము ఆపరేటర్ ఓవర్‌లోడింగ్ ఫంక్షన్‌ను నిర్వచిస్తాము (శూన్య ఆపరేటర్- () 
) దీనిలో రెండు వేరియబుల్స్ ఒక స్థానం ద్వారా తగ్గుతాయి. 
మేము -h1 వ్రాసేటప్పుడు ఇది ఆపరేటర్ ఓవర్‌లోడింగ్ ఫంక్షన్‌ను పిలుస్తుంది మరియు కన్స్ట్రక్టర్‌కు పంపిన విలువలను తగ్గిస్తుంది.
C ++ లో ఆపరేటర్ ఓవర్‌లోడింగ్‌పై ఈ కథనంతో కదులుతోంది.
 బైనరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తోంది 
ఇది రెండు ఒపెరాండ్లలో పనిచేసే ఆపరేటర్ యొక్క ఓవర్లోడింగ్. తరగతి ఎత్తు యొక్క అదే ఉదాహరణను తీసుకుందాం, కానీ ఈ సమయంలో, రెండు ఎత్తు వస్తువులను h1 మరియు h2 జోడించండి.
 ఉదాహరణ: 
# నేమ్‌స్పేస్ STD క్లాస్ ఎత్తు {పబ్లిక్: int అడుగులు, అంగుళాల ఎత్తు () {అడుగులు = 0 అంగుళాలు = 0} ఎత్తు (int f, int i) {feet = f inch = i} // ఓవర్‌లోడింగ్ (+) ఆపరేటర్ బైనరీ ఆపరేటర్ హైట్ ఆపరేటర్ + (ఎత్తు & డి 2) ఉపయోగించి // రెండు దూర వస్తువుల కలయిక // సూచన ద్వారా కాల్ చేయండి {// ఎత్తు h3 ను తిరిగి ఇవ్వడానికి ఒక వస్తువును సృష్టించండి // అడుగులు మరియు అంగుళాల అదనంగా జరుపుము h3.feet = feet + d2.feet h3. inch = inch + d2.inch // ఫలిత వస్తువు రిటర్న్‌ను తిరిగి ఇవ్వండి h3}} int main () {ఎత్తు h1 (3, 7) ఎత్తు h2 (6, 1) ఎత్తు h3 // ఓవర్‌లోడ్ చేసిన ఆపరేటర్‌ను ఉపయోగించండి h3 = h1 + h2 cout<< 'Sum of Feet & Inches: ' << h3.feet << ''' << h3.inch << endl return 0 } 
 అవుట్పుట్:  
 
 వివరణ:  
ఎత్తు ఆపరేటర్ + (ఎత్తు & h2), ఇక్కడ రిటర్న్స్_టైప్ ఫంక్షన్ క్లాస్ హైట్ కాబట్టి ఇది క్లాస్ హైట్ యొక్క ఆబ్జెక్ట్ h3 ను అందిస్తుంది. H3 = h1 + h2 అనే పంక్తిలో, h1 దాని తరగతుల వస్తువుల ఆపరేటర్ ఫంక్షన్‌ను పిలుస్తుంది మరియు h2 ను పరామితిగా తీసుకుంటుంది, అప్పుడు మేము h3.feet = feet + d2.feet మరియు h3.inch = inch + d2.inch ని వర్తింపజేస్తాము. h3 ఆబ్జెక్ట్‌తో అనుబంధించబడిన వేరియబుల్స్‌లో అడుగుల మరియు అంగుళాల వేరియబుల్స్ యొక్క విలువల మొత్తం. 
‘H3 = h1 + h2’ స్టేట్‌మెంట్ ఆపరేటర్ ఓవర్‌లోడ్ ఫంక్షన్‌ను ప్రారంభించినప్పుడు, ఆబ్జెక్ట్ h1 ఫంక్షన్‌ను ప్రారంభించే బాధ్యతను తీసుకుంది మరియు h2 ఫంక్షన్‌కు పంపబడే వాదన పాత్రను పోషిస్తుంది. పై ఇన్వొకేషన్ స్టేట్మెంట్ h3 = h1.operator + (h2) కు సమానం కాబట్టి h2 యొక్క డేటా సభ్యుడు నేరుగా యాక్సెస్ చేయబడతారు మరియు h2 యొక్క డేటా సభ్యుడు (అది వాదనగా ఆమోదించబడుతుంది) డాట్ ఆపరేటర్ ఉపయోగించి యాక్సెస్ చేయబడుతుంది.
సెలీనియంలో డేటా నడిచే పరీక్ష
 ఆపరేటర్ ఓవర్‌లోడింగ్ కోసం నియమాలు 
ప్రస్తుతం ఉన్న ఆపరేటర్లను మాత్రమే ఓవర్‌లోడ్ చేయవచ్చు మరియు కొత్త ఆపరేటర్లను ఓవర్‌లోడ్ చేయలేరు
ఓవర్‌లోడ్ చేసిన ఆపరేటర్‌లో వినియోగదారు నిర్వచించిన డేటా రకానికి కనీసం ఒక ఆపరేషన్ ఉండాలి.
కొన్ని ఆపరేటర్లను ఓవర్‌లోడ్ చేయడానికి మేము ఫ్రెండ్ ఫంక్షన్‌ను ఉపయోగించము. అయినప్పటికీ, సభ్యుల విధులు ఆ ఆపరేటర్లను ఓవర్లోడ్ చేయడానికి ఉపయోగించవచ్చు.
సభ్యుల ఫంక్షన్ ద్వారా అన్‌యరీ ఆపరేటర్లు ఓవర్‌లోడ్ అయినప్పుడు వారు స్పష్టమైన వాదనలు తీసుకోరు, కానీ, ఫ్రెండ్ ఫంక్షన్ ద్వారా ఓవర్‌లోడ్ అయినట్లయితే వారు ఒక వాదనను తీసుకుంటారు.
సభ్యుల ఫంక్షన్ ద్వారా బైనరీ ఆపరేటర్లు ఓవర్‌లోడ్ అయినప్పుడు వారు ఒక స్పష్టమైన వాదనను తీసుకుంటారు మరియు ఫ్రెండ్ ఫంక్షన్ ద్వారా ఓవర్‌లోడ్ అయితే వారు రెండు స్పష్టమైన వాదనలు తీసుకుంటారు.
ఈ విధంగా ‘సి ++ లో ఆపరేటర్ ఓవర్‌లోడింగ్’ పై ఈ వ్యాసం ముగిసింది. మీరు మరింత తెలుసుకోవాలనుకుంటే, విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత జావా శిక్షణను చూడండి. ఎడురేకా  హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి కోర్సు రూపొందించబడింది.
 మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.