ఉదాహరణ # 1: C++లో “==” ఆపరేటర్‌ని ఓవర్‌లోడ్ చేయడం:
C++లో “==” ఆపరేటర్‌ని ఓవర్‌లోడ్ చేయడం కోసం, మేము ఈ క్రింది C++ క్లాస్‌ని డిజైన్ చేసాము:
మా C++ తరగతి పేరు ProductPrice. ఈ తరగతిలో, మాకు ప్రైవేట్ మెంబర్ “ధర” ఉంది. ఆ తర్వాత, మాకు కొన్ని పబ్లిక్ మెంబర్ ఫంక్షన్‌లు ఉన్నాయి. 'యూజర్‌ఇన్‌పుట్' అనే మొదటి ఫంక్షన్, ఉత్పత్తి ధరను వినియోగదారు నుండి ఇన్‌పుట్‌గా తీసుకుంటుంది. అప్పుడు, C++లో “==” ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడానికి మాకు ఫంక్షన్ ఉంది. మేము ఈ ఫంక్షన్‌కి ప్రోడక్ట్ ప్రైస్ క్లాస్‌లోని ఆబ్జెక్ట్‌ని పాస్ చేసాము. ఈ ఫంక్షన్‌లో, రెండు ఉత్పత్తుల ధరలు సమానంగా ఉన్నట్లయితే, 'తప్పు'గా ఉన్నట్లయితే 'నిజం' అని అందించబడే 'if' స్టేట్‌మెంట్ మాకు ఉంది.
దీన్ని పరీక్షించడానికి, మేము దిగువ చిత్రంలో చూపిన డ్రైవర్ ఫంక్షన్‌ని కలిగి ఉన్నాము:
మా “ప్రధాన()” ఫంక్షన్‌లో, మేము మొదట మా తరగతికి చెందిన రెండు వస్తువులను సృష్టించాము. ఆపై, వినియోగదారు నుండి ఇన్‌పుట్‌గా రెండు ఉత్పత్తుల ధరలను తీసుకోవడానికి మేము రెండు వస్తువులలో ఒక్కొక్కటిగా “యూజర్‌ఇన్‌పుట్” ఫంక్షన్‌ని పిలిచాము. ఆ తర్వాత, రెండు ధరలు సమానంగా ఉంటే సందేశాన్ని ప్రింట్ చేయడానికి మరియు కాకపోతే మరొక సందేశాన్ని ప్రింట్ చేయడానికి మనకు “if” స్టేట్‌మెంట్ ఉంటుంది.
కింది ఆదేశాన్ని ఉపయోగించి మేము ఈ ప్రోగ్రామ్‌ను కంపైల్ చేసాము:
$ g++ ComparisonOperator.cpp –o ComparisonOperator
అప్పుడు, మేము క్రింద చూపిన ఆదేశాన్ని ఉపయోగించి దీన్ని అమలు చేసాము:
$ . / కంపారిజన్ ఆపరేటర్ 
ఈ కోడ్‌ని అమలు చేసిన తర్వాత, కింది చిత్రంలో చూపిన విధంగా మొదటి ఉత్పత్తి ధరను నమోదు చేయమని మమ్మల్ని అడిగారు:
ఆపై, దిగువ చిత్రంలో చూపిన విధంగా రెండవ ఉత్పత్తి ధరను నమోదు చేయమని మమ్మల్ని అడిగారు:
మేము రెండు ఉత్పత్తులకు ఒకే ధరలను నమోదు చేసినందున, మా “==” ఆపరేటర్ విజయవంతంగా ఓవర్‌లోడ్ చేయబడిందని క్రింది అవుట్‌పుట్‌లో చూడవచ్చు.
ఇప్పుడు, 'else' స్టేట్‌మెంట్ కోసం దీన్ని పరీక్షించడానికి, దిగువ చిత్రంలో చూపిన విధంగా మేము రెండు వేర్వేరు ఉత్పత్తి ధరలను నమోదు చేసాము:
ఉదాహరణ # 2: C++లో “!=” ఆపరేటర్‌ని ఓవర్‌లోడ్ చేయడం:
C++లో “!=” ఆపరేటర్‌ని ఓవర్‌లోడ్ చేయడం కోసం, మేము ఈ క్రింది C++ క్లాస్‌ని డిజైన్ చేసాము:
ఈ కార్యక్రమం మా మొదటి ఉదాహరణ వలె కనిపిస్తుంది. ఒకే తేడా ఏమిటంటే, మేము ప్రతిచోటా “==” ఆపరేటర్‌ని “!=” ఆపరేటర్‌తో భర్తీ చేసాము.
దీన్ని పరీక్షించడానికి, మేము దిగువ చిత్రంలో చూపిన డ్రైవర్ ఫంక్షన్‌ని కలిగి ఉన్నాము:
రెండు ఉత్పత్తుల ధరలను వినియోగదారు నుండి ఇన్‌పుట్‌గా తీసుకోవడానికి మేము మా “ప్రధాన()” ఫంక్షన్‌లో “యూజర్‌ఇన్‌పుట్” ఫంక్షన్‌ని ఒక్కొక్కటిగా రెండు ఆబ్జెక్ట్‌లతో పిలిచాము. ఆ తర్వాత, రెండు ధరలు సమానంగా లేకుంటే ఒక సందేశాన్ని ప్రింట్ చేయడానికి మరియు అవి ఉంటే మరొక సందేశాన్ని ప్రింట్ చేయడానికి మనకు “if” స్టేట్‌మెంట్ ఉంటుంది.
మేము ఈ కోడ్‌ను రెండు వేర్వేరు ఉత్పత్తి ధరలతో అమలు చేసినప్పుడు, మా అసమానత ఆపరేటర్ విజయవంతంగా ఓవర్‌లోడ్ చేయబడిందని మేము గుర్తించాము, మీరు ఈ క్రింది చిత్రం నుండి చూడవచ్చు:
ఇప్పుడు, 'else' స్టేట్‌మెంట్ కోసం దీన్ని పరీక్షించడానికి, దిగువ చిత్రంలో చూపిన విధంగా మేము రెండు సారూప్య ఉత్పత్తి ధరలను నమోదు చేసాము:
ఉదాహరణ # 3: C++లో “>” ఆపరేటర్‌ని ఓవర్‌లోడ్ చేయడం:
C++లో “>” ఆపరేటర్‌ని ఓవర్‌లోడ్ చేయడం కోసం, మేము ఈ క్రింది C++ క్లాస్‌ని డిజైన్ చేసాము:
ఈ ప్రోగ్రామ్ కూడా పైన ఉన్న మా ఉదాహరణల మాదిరిగానే ఉంటుంది. ఒకే తేడా ఏమిటంటే, మేము '!=' ఆపరేటర్‌ని ప్రతిచోటా '>' ఆపరేటర్‌తో భర్తీ చేసాము.
దీన్ని పరీక్షించడానికి, మేము దిగువ చిత్రంలో చూపిన డ్రైవర్ ఫంక్షన్‌ని కలిగి ఉన్నాము:
రెండు ఉత్పత్తుల ధరలను వినియోగదారు నుండి ఇన్‌పుట్‌గా తీసుకోవడానికి మేము మా “ప్రధాన()” ఫంక్షన్‌లో “యూజర్‌ఇన్‌పుట్” ఫంక్షన్‌ని ఒక్కొక్కటిగా రెండు ఆబ్జెక్ట్‌లతో పిలిచాము. ఆ తర్వాత, మొదటి ధర మరొకదాని కంటే ఎక్కువగా ఉంటే సందేశాన్ని ప్రింట్ చేయడానికి మరియు లేకపోతే మరొక సందేశాన్ని ప్రింట్ చేయడానికి మనకు “if” స్టేట్‌మెంట్ ఉంటుంది.
మేము ఈ కోడ్‌ని రెండు వేర్వేరు ఉత్పత్తి ధరలతో అమలు చేసినప్పుడు, మా కంటే ఎక్కువ ఆపరేటర్ విజయవంతంగా ఓవర్‌లోడ్ చేయబడిందని మేము గుర్తించాము, మీరు ఈ క్రింది చిత్రం నుండి చూడవచ్చు:
ఇప్పుడు, 'else' స్టేట్‌మెంట్ కోసం దీన్ని పరీక్షించడానికి, దిగువ చిత్రంలో చూపిన విధంగా మేము రెండు సారూప్య ఉత్పత్తి ధరలను నమోదు చేసాము:
ఉదాహరణ # 4: C++లో “<” ఆపరేటర్‌ని ఓవర్‌లోడ్ చేయడం:
C++లో “<” ఆపరేటర్‌ని ఓవర్‌లోడ్ చేయడం కోసం, మేము ఈ క్రింది C++ క్లాస్‌ని డిజైన్ చేసాము:
ఈ ప్రోగ్రామ్ కూడా పైన ఉన్న మా ఉదాహరణల మాదిరిగానే ఉంటుంది. ఒకే తేడా ఏమిటంటే, మేము '>' ఆపరేటర్‌ని ప్రతిచోటా '<' ఆపరేటర్‌తో భర్తీ చేసాము.
దీన్ని పరీక్షించడానికి, దిగువ చిత్రంలో చూపిన డ్రైవర్ ఫంక్షన్‌ని మేము కలిగి ఉన్నాము:
వినియోగదారు నుండి ఇన్‌పుట్‌గా రెండు ఉత్పత్తుల ధరలను తీసుకోవడానికి మేము మా “ప్రధాన()” ఫంక్షన్‌లో “యూజర్‌ఇన్‌పుట్” ఫంక్షన్‌ని ఒక్కొక్కటిగా రెండు వస్తువులతో పిలిచాము. ఆ తర్వాత, మొదటి ధర మరొకదాని కంటే తక్కువగా ఉంటే సందేశాన్ని ప్రింట్ చేయడానికి మరియు లేకపోతే మరొక సందేశాన్ని ప్రింట్ చేయడానికి మనకు “if” స్టేట్‌మెంట్ ఉంటుంది.
మేము ఈ కోడ్‌ని రెండు వేర్వేరు ఉత్పత్తి ధరలతో అమలు చేసినప్పుడు, మా తక్కువ ఆపరేటర్ విజయవంతంగా ఓవర్‌లోడ్ చేయబడిందని మేము గుర్తించాము, మీరు ఈ క్రింది చిత్రం నుండి చూడవచ్చు:
ఇప్పుడు, “else” స్టేట్‌మెంట్ కోసం దీన్ని పరీక్షించడానికి, మేము మళ్లీ రెండు వేర్వేరు ఉత్పత్తి ధరలను నమోదు చేసాము, కానీ ఈసారి, మొదటి ఉత్పత్తి ధర రెండవదాని కంటే ఎక్కువగా ఉంది, దిగువ చిత్రంలో చూపిన విధంగా:
ఉదాహరణ # 5: C++లో “>=” ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడం:
C++లో “>=” ఆపరేటర్‌ని ఓవర్‌లోడ్ చేయడం కోసం, మేము ఈ క్రింది C++ క్లాస్‌ని డిజైన్ చేసాము:
ఇది పైన ఉన్న మా ఉదాహరణల నుండి కొద్దిగా భిన్నంగా ఉంటుంది. ఈసారి ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తున్నప్పుడు, “||”తో వేరు చేయబడిన “if” స్టేట్‌మెంట్‌లో మాకు రెండు షరతులు ఉన్నాయి. చిహ్నం. ఒక ఉత్పత్తి ధర మరొకదాని కంటే ఎక్కువ లేదా సమానంగా ఉందో లేదో ఈ ప్రకటన తనిఖీ చేస్తుంది.
దీన్ని పరీక్షించడానికి, మేము దిగువ చిత్రంలో చూపిన డ్రైవర్ ఫంక్షన్‌ని కలిగి ఉన్నాము:
వినియోగదారు నుండి ఇన్‌పుట్‌గా రెండు ఉత్పత్తుల ధరలను తీసుకోవడానికి మేము మా “ప్రధాన()” ఫంక్షన్‌లో “యూజర్‌ఇన్‌పుట్” ఫంక్షన్‌ని ఒక్కొక్కటిగా రెండు వస్తువులతో పిలిచాము. ఆ తర్వాత, మొదటి ధర మరొకదాని కంటే ఎక్కువ లేదా సమానంగా ఉంటే మెసేజ్‌ను ప్రింట్ చేయడానికి మనకు “if” స్టేట్‌మెంట్ ఉంటుంది మరియు లేకపోతే మరొక సందేశం ఉంటుంది.
మేము ఈ కోడ్‌ని రెండు వేర్వేరు ఉత్పత్తి ధరలతో అమలు చేసినప్పుడు, మా కంటే ఎక్కువ లేదా ఆపరేటర్‌కు సమానమైనది విజయవంతంగా ఓవర్‌లోడ్ చేయబడిందని మేము గుర్తించాము, మీరు ఈ క్రింది చిత్రం నుండి చూడవచ్చు:
ఇప్పుడు, 'else' స్టేట్‌మెంట్ కోసం దీనిని పరీక్షించడానికి, దిగువ చిత్రంలో చూపిన విధంగా మేము మొదటి ఉత్పత్తి ధరను రెండవదాని కంటే తక్కువగా నమోదు చేసాము:
ఉదాహరణ # 6: C++లో “<=” ఆపరేటర్‌ని ఓవర్‌లోడ్ చేయడం:
మా ఐదవ ఉదాహరణ వలె అదే పద్ధతిని అనుసరించి, మేము “<=” ఆపరేటర్‌ను కూడా ఓవర్‌లోడ్ చేసాము మరియు దాని కోడ్ క్రింది విధంగా ఉంది:
విభిన్న విలువలతో ఈ ప్రోగ్రామ్ యొక్క అమలు ఫలితాలు క్రింది చిత్రాలలో చూపబడ్డాయి:
ముగింపు:
ఉబుంటు 20.04లో C++లోని ఆరు కంపారిజన్ ఆపరేటర్లను మీరు ఎలా ఓవర్‌లోడ్ చేయవచ్చో ఈ ఆర్టికల్ బాగా వివరించింది. మేము ఆపరేటర్ ఓవర్‌లోడింగ్ యొక్క క్లుప్త పరిచయంతో ప్రారంభించాము, ఆపై C++లోని మొత్తం ఆరు కంపారిజన్ ఆపరేటర్లు ఓవర్‌లోడ్ చేయబడ్డాయి. ఈ పద్ధతులన్నింటిని ప్రదర్శించడానికి మేము అదే వినియోగదారు నిర్వచించిన తరగతిని ఉపయోగించాము. మీరు ఈ పద్ధతులను అనుసరించిన తర్వాత, మీరు ఏదైనా ఇతర వినియోగదారు నిర్వచించిన తరగతి కోసం ఈ పోలిక ఆపరేటర్లను ఓవర్‌లోడ్ చేయగలరు.