C++ అనేక unary ఆపరేటర్లకు మద్దతు ఇస్తుంది, ప్రతి ఒక్కటి వేరియబుల్స్‌ను మార్చడంలో ఒక ప్రత్యేక ప్రయోజనాన్ని అందిస్తాయి. లూప్‌లు మరియు వివిధ అల్గారిథమ్‌లలో సాధారణంగా ఉపయోగించే ఇంక్రిమెంట్ మరియు డిక్రిమెంట్ ఆపరేటర్‌లతో ప్రారంభిద్దాం.
ఉదాహరణ 1: ఇంక్రిమెంట్ (++) మరియు తగ్గింపు (–) ఆపరేటర్లు
ఇంక్రిమెంట్ (++) మరియు తగ్గింపు (-) unary ఆపరేటర్లు C++లో ఒక వేరియబుల్ విలువను వరుసగా 1 పెంచడం లేదా తగ్గించడం ద్వారా సవరించడానికి ప్రాథమిక సాధనాలు. ఇంక్రిమెంట్ ఆపరేటర్ (++) వేరియబుల్ విలువకు 1ని జోడిస్తుంది, అయితే డిక్రిమెంట్ ఆపరేటర్ (-) 1ని తీసివేస్తుంది. ఈ ఆపరేటర్లను పూర్ణాంకం, ఫ్లోటింగ్ పాయింట్ మరియు పాయింటర్ వేరియబుల్‌లకు అన్వయించవచ్చు, వాటి వినియోగంలో సౌలభ్యాన్ని అందిస్తుంది.
ఆచరణాత్మక ఉదాహరణ ద్వారా ఈ ఆపరేటర్లను అన్వేషిద్దాం:
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
int కౌంటర్ = 0 ;
// ఇంక్రిమెంట్ ఆపరేటర్
కోట్ << 'ప్రారంభ విలువ:' << కౌంటర్ << endl ;
కౌంటర్ ++ ;
కోట్ << 'పెంపుదల తర్వాత విలువ:' << కౌంటర్ << endl ;
// డిక్రిమెంట్ ఆపరేటర్
కౌంటర్ -- ;
కోట్ << 'తగ్గిన తర్వాత విలువ:' << కౌంటర్ << endl ;
తిరిగి 0 ;
}
ఈ సాధారణ C++ ప్రోగ్రామ్ “#include
ఈ ఆపరేషన్ తర్వాత, మరొక 'కౌట్' స్టేట్‌మెంట్ ఉపయోగించి 'కౌంటర్' యొక్క నవీకరించబడిన విలువ ప్రదర్శించబడుతుంది. తదనంతరం, మేము 'కౌంటర్' విలువను 1 ద్వారా తగ్గించడానికి డిక్రీమెంట్ ఆపరేటర్ (కౌంటర్-)ని ఉపయోగిస్తాము. ఫలితం కన్సోల్‌లో తర్వాత ప్రదర్శించబడుతుంది. అంతిమంగా, ప్రోగ్రామ్ “రిటర్న్ 0;”తో ముగుస్తుంది. విజయవంతమైన అమలును సూచించే ప్రకటన.
అవుట్‌పుట్ ఇమేజ్ ప్రారంభ విలువ, ఇంక్రిమెంట్ తర్వాత విలువ మరియు తగ్గిన విలువను చూపుతుంది.
ఉదాహరణ 2: సానుకూల (+) మరియు ప్రతికూల (-) ఆపరేటర్లు
సానుకూల యునరీ ఆపరేటర్ చాలా అరుదుగా ఉపయోగించబడుతుంది, వేరియబుల్ యొక్క చిహ్నాన్ని మార్చడానికి ప్రతికూల ఆపరేటర్ ప్రాథమికంగా ఉంటుంది.
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
int సానుకూల విలువ = 10 ;
int ప్రతికూల విలువ = - సానుకూల విలువ ;
కోట్ << 'సానుకూల విలువ:' << సానుకూల విలువ << endl ;
కోట్ << 'ప్రతికూల విలువ:' << ప్రతికూల విలువ << endl ;
తిరిగి 0 ;
}
మేము ఈ ఉదాహరణ కోడ్ కోసం 'పాజిటివ్ వాల్యూ' మరియు 'నెగటివ్ వాల్యూ' అనే రెండు పూర్ణాంక వేరియబుల్స్‌ని ప్రారంభిస్తాము. “పాజిటివ్ వాల్యూ” 10 విలువతో కేటాయించబడుతుంది. తదనంతరం, మేము “ప్రతికూల విలువ”ని ప్రకటిస్తాము మరియు అనారీ మైనస్ ఆపరేటర్‌ని ఉపయోగించి “పాజిటివ్ వాల్యూ” నిరాకరణతో దానిని కేటాయిస్తాము. ఈ ఆపరేటర్ అసలు విలువ యొక్క చిహ్నాన్ని సమర్థవంతంగా మారుస్తుంది. మేము కన్సోల్‌లో సానుకూల మరియు ప్రతికూల అవుట్‌పుట్ రెండింటినీ ప్రదర్శించడానికి “కౌట్” స్టేట్‌మెంట్‌ను ఉపయోగిస్తాము. చివరగా, ప్రోగ్రామ్ 0ని అందిస్తుంది, ఇది ప్రధాన ఫంక్షన్ విజయవంతంగా పూర్తి చేయబడిందని సూచిస్తుంది.
అమలు చేసినప్పుడు, ఈ ప్రోగ్రామ్ సానుకూల మరియు ప్రతికూల విలువలను అందిస్తుంది.
ఉదాహరణ 3: లాజికల్ కాదు (!) ఆపరేటర్
C++లో unary ఆపరేటర్, “!” ద్వారా సూచించబడుతుంది చిహ్నం, లాజికల్ NOT ఆపరేటర్ అని పిలుస్తారు. ఇచ్చిన వ్యక్తీకరణ యొక్క సత్య విలువను తారుమారు చేయడానికి ఇది రూపొందించబడింది. ఇది ఒకే ఒపెరాండ్‌పై పనిచేస్తుంది, ఇది సాధారణంగా తార్కిక వ్యక్తీకరణ లేదా షరతు. లాజికల్ NOT ఆపరేషన్ ఒపెరాండ్ 'తప్పు' అయినప్పుడు 'నిజమైన' ఫలితాన్ని ఇస్తుంది మరియు ఒపెరాండ్ 'నిజం' అయినప్పుడు 'తప్పుడు' ఫలితాన్ని ఇస్తుంది.
లాజికల్ NOT ఆపరేటర్ వినియోగాన్ని ప్రదర్శించే ఒక సాధారణ ఉదాహరణ ఇక్కడ ఉంది:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
బూల్ నిజం = నిజం ;
బూల్ తప్పు = తప్పుడు ;
బూల్ ఫలితం నిజం కాదు = ! నిజం ;
బూల్ ఫలితం తప్పు కాదు = ! తప్పు ;
కోట్ << 'అసలు విలువ:' << నిజం << ', తర్వాత కాదు:' << ఫలితం నిజం కాదు << endl ;
కోట్ << 'అసలు విలువ:' << తప్పు << ', తర్వాత కాదు:' << ఫలితం తప్పు కాదు << endl ;
తిరిగి 0 ;
}
ఈ ఉదాహరణలో, మేము రెండు బూలియన్ వేరియబుల్స్, “isTrue” మరియు “isFalse”ని ప్రకటిస్తాము. మేము ప్రతి వేరియబుల్‌కు లాజికల్ NOT ఆపరేటర్‌ని వర్తింపజేస్తాము, ఫలితాలను వరుసగా “resultNotTrue” మరియు “resultNotFalse”లో నిల్వ చేస్తాము. ప్రోగ్రామ్ తదనంతరం అసలు విలువలు మరియు రెండు వేరియబుల్స్ కోసం లాజికల్ NOT ఆపరేషన్ ఫలితాలను ముద్రిస్తుంది.
ఈ ప్రోగ్రామ్‌ని అమలు చేసిన తర్వాత, లాజికల్ NOT ఆపరేటర్ “isTrue” (ప్రారంభంలో ఒప్పుకు సెట్) యొక్క సత్య విలువను రివర్స్ చేసి, దాన్ని తప్పుగా రెండరింగ్ చేయడం మనం గమనించవచ్చు. అదేవిధంగా, ఇది 'ఇస్‌ఫాల్స్' (వాస్తవానికి తప్పుడు) యొక్క సత్య విలువను విలోమం చేస్తుంది, ఇది నిజం అవుతుంది.
లాజికల్ NOT ఆపరేటర్ ద్వారా సాధించబడిన సత్య విలువల విలోమతను అవుట్‌పుట్ స్పష్టంగా వివరిస్తుంది.
ఉదాహరణ 4: Bitwise NOT (~) ఆపరేటర్
C++లోని బిట్‌వైస్ NOT ఆపరేటర్ (~) అనేది ఒక యునరీ ఆపరేటర్, ఇది దాని ప్రతి బిట్ యొక్క బిట్‌వైస్ నెగెషన్‌ను నిర్వహిస్తుంది. ఇది ప్రాథమిక డేటా రకాలు, ప్రత్యేకంగా పూర్ణాంకాల వంటి సమగ్రమైన వాటితో పనిచేస్తుంది. ఒపెరాండ్‌లోని ప్రతి వ్యక్తి బిట్‌ను విలోమం చేయడం ద్వారా ఫలితం సాధించబడుతుంది, 0sని 1sకి మరియు 1s నుండి 0sకి మార్చడం.
దాని వినియోగాన్ని వివరించడానికి, కింది కోడ్ స్నిప్పెట్‌ను పరిగణించండి:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
int అసలు విలువ = 5 ;
int ఫలితంBitwiseNot = ~ అసలు విలువ ;
కోట్ << 'అసలు విలువ:' << అసలు విలువ << ', Bitwise NOT తర్వాత:' << ఫలితంBitwiseNot << endl ;
తిరిగి 0 ;
}
ఈ ఉదాహరణలో, మేము “5” విలువతో “ఒరిజినల్ వాల్యూ” పూర్ణాంక వేరియబుల్‌ని ప్రకటిస్తాము. తరువాత, మేము ఈ వేరియబుల్‌పై బిట్‌వైస్ నాట్ ఆపరేటర్ (~)ని ఉపయోగిస్తాము. ఈ వేరియబుల్ యొక్క ఫలితం 'resultBitwiseNot'లో నిల్వ చేయబడుతుంది. ప్రోగ్రామ్ 'కౌట్' స్టేట్‌మెంట్‌ని ఉపయోగించడం ద్వారా బిట్‌వైస్ నాట్ ఆపరేషన్ తర్వాత అసలు విలువ మరియు ఫలితాన్ని ముద్రిస్తుంది.
మేము ఈ ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు, బిట్‌వైస్ నాట్ ఆపరేటర్ “ఒరిజినల్ వాల్యూ” యొక్క బైనరీ ప్రాతినిధ్యంలోని ప్రతి బిట్‌ను విలోమం చేసి, ఫలితంగా కొత్త విలువను చూస్తాము.
ఉదాహరణ 5: చిరునామా మరియు పరోక్ష ఆపరేటర్లు
'&' గుర్తుతో సూచించబడిన ఆపరేటర్ యొక్క చిరునామా, వేరియబుల్ యొక్క మెమరీ స్థానాన్ని తిరిగి పొందేందుకు ఉపయోగపడుతుంది. ఇది వేరియబుల్‌కు పాయింటర్‌ను తిరిగి ఇస్తుంది, ఇది దాని విలువకు పరోక్ష ప్రాప్యతను అనుమతిస్తుంది. పాయింటర్ ద్వారా పేర్కొన్న మెమరీ లొకేషన్‌లో నిల్వ చేయబడిన విలువను పరోక్ష లేదా డీరిఫరెన్స్ ఆపరేటర్ (*) పొందుతుంది. ఇది పరోక్షంగా పాయింటర్ ద్వారా వాస్తవ డేటాతో పని చేయడానికి ఒక మార్గాన్ని అందిస్తుంది.
ఒక ఉదాహరణతో భావనను గ్రహిద్దాం:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
int విలువ = 99 ;
కోట్ << 'అసలు విలువ:' << విలువ << endl ;
int * ptr = & విలువ ;
కోట్ << 'మెమరీ చిరునామా:' << ptr << endl ;
int విలువను తిరిగి పొందింది = * ptr ;
కోట్ << 'రిట్రీవ్డ్ వాల్యూ:' << విలువను తిరిగి పొందింది << endl ;
తిరిగి 0 ;
}
ఈ కోడ్ చిరునామా మరియు పరోక్ష ఆపరేటర్ల వినియోగాన్ని ఉదహరిస్తుంది. మొదట, 'విలువ' అనే పేరుగల పూర్ణాంక వేరియబుల్ 99 విలువతో ప్రారంభించబడుతుంది. 'విలువ' యొక్క అసలు విలువ కన్సోల్‌కు అవుట్‌పుట్ చేయబడుతుంది. తదనంతరం, “ptr” పాయింటర్ వేరియబుల్ ప్రకటించబడింది మరియు “విలువ” యొక్క మెమరీ చిరునామాను “ptr”కి కేటాయించడానికి ఆపరేటర్ యొక్క చిరునామా (&) ఉపయోగించబడుతుంది. ప్రోగ్రామ్ ఈ మెమరీ చిరునామాను అవుట్‌పుట్ చేస్తుంది, 'చిరునామా' ఆపరేటర్ యొక్క ప్రాథమిక ఆపరేషన్‌ను ప్రదర్శిస్తుంది.
ఆ తర్వాత, “రిట్రీవ్డ్ వాల్యూ” అనే కొత్త పూర్ణాంకం వేరియబుల్ ప్రకటించబడుతుంది మరియు “ptr” ద్వారా సూచించబడిన మెమరీ చిరునామా వద్ద నిల్వ చేయబడిన విలువను తిరిగి పొందడానికి పరోక్ష ఆపరేటర్ (*) ఉపయోగించబడుతుంది. తిరిగి పొందిన విలువ కన్సోల్‌కు అవుట్‌పుట్ చేయబడుతుంది.
ముగింపు
ఈ కథనం C++లో unary ఆపరేటర్ల సమగ్ర అన్వేషణను అందించింది. మేము అనారీ ఆపరేటర్లను అంకగణితం, తార్కికం, బిట్‌వైస్ మరియు చిరునామా మరియు పరోక్షానికి సంబంధించిన వివిధ రకాలుగా వర్గీకరించడం ద్వారా ప్రారంభించాము. ఈ ఆపరేటర్ల ఉపయోగకరమైన అనువర్తనాన్ని ప్రదర్శించడానికి వాస్తవ-ప్రపంచ పరిస్థితులు ఉదహరించబడ్డాయి. ఈ ఆపరేటర్లు C++ ప్రోగ్రామింగ్‌లో కీలక పాత్రలు పోషిస్తారు, ఇది డెవలపర్‌లను పాయింటర్‌లతో సమర్థవంతంగా పని చేయడానికి మరియు మెమరీని నిర్వహించడానికి అనుమతిస్తుంది.