C++ టెర్నరీ ఆపరేటర్

C Ternari Aparetar

“షరతులతో కూడిన ఆపరేటర్ మరియు if-else స్టేట్‌మెంట్ రెండూ ఒకే టెక్నిక్‌ని ఉపయోగిస్తాయి, అయితే షరతులతో కూడిన ఆపరేటర్ if-else వ్యక్తీకరణలను సాధ్యమయ్యేంత చిన్నదిగా చేస్తుంది, అయితే if-else వ్యక్తీకరణ ఎక్కువ స్థలాన్ని తీసుకుంటుంది. కొన్ని ప్రోగ్రామింగ్ భాషలలో, చాలా మంది ఆపరేటర్‌లకు అవసరమయ్యే సాధారణ ఒకటి లేదా రెండింటికి విరుద్ధంగా మూడు ఆపరేటర్‌లను అంగీకరించే టెర్నరీ ఆపరేటర్ అని పిలువబడే ఒక ఆపరేటర్ ఉంది. ఇది ప్రాథమిక if-else బ్లాక్‌ను ఘనీభవించే సాధనాన్ని అందిస్తుంది. ఈ గైడ్‌లో, C++లోని టెర్నరీ ఆపరేటర్ ఉదాహరణల ద్వారా కవర్ చేయబడుతుంది. కొన్ని సందర్భాల్లో, C++ అప్లికేషన్‌లలో if else స్టేట్‌మెంట్‌ను టెర్నరీ ఆపరేటర్‌తో భర్తీ చేయవచ్చు, దీనిని తరచుగా షరతులతో కూడిన ఆపరేటర్ అని పిలుస్తారు.

C++లో టెర్నరీ ఆపరేటర్ యొక్క సింటాక్స్

టెర్నరీ ఆపరేటర్‌కు మూడు ఆపరాండ్‌లు అవసరం: షరతులతో కూడినది, నిజం మరియు తప్పు. టెర్నరీ ఆపరేటర్ పరీక్ష స్థితిని విశ్లేషించి, ఫలితాన్ని బట్టి కోడ్ బ్లాక్‌ని అమలు చేస్తున్నప్పుడు, వాక్యనిర్మాణం ఇలా ఉంటుంది:

# (exp_1) ? exp_2 : exp_3

ఇక్కడ “exp” వ్యక్తీకరణను సూచిస్తుంది. వ్యక్తీకరణ యొక్క ఫలితంపై ఆధారపడి, ఈ ఆపరేటర్ రెండు విలువలలో ఒకదాన్ని అందిస్తుంది. వ్యక్తీకరణలు 2 మరియు 3 మూల్యాంకనం చేయబడతాయి మరియు “exp_1”ని బూలియన్ ట్రూగా మూల్యాంకనం చేస్తే వాటి విలువలు తుది ఫలితాలుగా అందించబడతాయి; లేకపోతే, వ్యక్తీకరణ 1 బూలియన్ తప్పుగా మూల్యాంకనం చేయబడుతుంది మరియు వ్యక్తీకరణ 2 మూల్యాంకనం చేయబడుతుంది మరియు దాని విలువ తుది ఫలితంగా అందించబడుతుంది.



ఉదాహరణ 1

C++ యొక్క టెర్నరీ ఆపరేటర్‌ని ఎలా ఉపయోగించాలో చూపే సూటిగా ఉదాహరణ ప్రోగ్రామ్ ఇక్కడ ఉంది.



# చేర్చండి

# చేర్చండి

నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;

int ప్రధాన ( ) {
రెట్టింపు CGPA ;
కోట్ <> CGPA ;

స్ట్రింగ్ విద్యార్థి_ఫలితం = ( CGPA >= 1.5 ) ? 'ఉత్తీర్ణత' : 'విఫలమైంది' ;

కోట్ << 'మీరు' << విద్యార్థి_ఫలితం << ' అర్థ వార్షికం.' ;

తిరిగి 0 ;
}



ప్రోగ్రామ్‌లో, మేము మా హెడర్ విభాగాన్ని C++ లైబ్రరీలతో నింపాము. ఆ తర్వాత, మేము 'యూజింగ్' అనే కీవర్డ్‌తో నేమ్‌స్పేస్ stdని జోడించాము. అప్పుడు, 'డబుల్' డేటా రకంతో వేరియబుల్ 'CGPA' దాని లోపల ప్రకటించబడింది. తదుపరి లైన్‌లో, కౌట్ ఆదేశాన్ని ముద్రించడం ద్వారా CGPAని నమోదు చేయమని మేము వినియోగదారుని కోరాము. సిన్ కమాండ్‌తో, వినియోగదారులు CGPAని జోడిస్తారు.

అప్పుడు, మేము టెర్నరీ ఆపరేటర్‌ని కలిగి ఉన్న “స్టూడెంట్_రిజల్ట్” అనే మరొక వేరియబుల్‌ని సృష్టించాము. టెర్నరీ ఆపరేటర్‌కు ఇక్కడ మూడు వ్యక్తీకరణలు అవసరం. మొదటిది, వినియోగదారు నమోదు చేసిన CGPA “1.5” కంటే ఎక్కువగా ఉందా లేదా సమానంగా ఉందో లేదో తనిఖీ చేసే షరతు. అలా అయితే, “ఉత్తీర్ణత” అనే ప్రకటన ముద్రించబడుతుంది లేదా మూడవ వ్యక్తీకరణ ముద్రించబడుతుంది. మీరు cout ఆదేశాన్ని ఉపయోగించినప్పుడు ఫలితం చూపబడుతుంది.

వినియోగదారు CGPA “3.5”ని టైప్ చేసారని అనుకుందాం. CGPA >= 1.5 ప్రమాణాన్ని నెరవేర్చి, ఒప్పుకు మూల్యాంకనం చేస్తుంది. కాబట్టి, ఫలితం మొదటి పదం 'ఉత్తీర్ణత' ఇవ్వబడుతుంది.



వినియోగదారు రకాలు 1.00 అని చెప్పండి. ఫలితంగా, పరిస్థితి CGPA >= 1.5 తప్పుగా మూల్యాంకనం చేయబడింది. అందువల్ల, ఫలితం 'విఫలమైంది' అనే రెండవ వ్యక్తీకరణ ఇవ్వబడింది.

ఉదాహరణ 2

C++లోని కొన్ని రకాల if else స్టేట్‌మెంట్‌లను టెర్నరీ ఆపరేటర్‌తో మార్చుకోవచ్చు. మేము ఈ కోడ్‌ని ఉదాహరణగా మార్చవచ్చు. మొదటి ఉదాహరణ ప్రోగ్రామ్ if-else కండిషన్‌ను ఉపయోగిస్తుంది మరియు ఇతర ఉదాహరణ ప్రోగ్రామ్ టెర్నరీ ఆపరేటర్‌ను ఉపయోగిస్తుంది.

# చేర్చండి

నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;

int ప్రధాన ( ) {

int ఒకదానిపై = - 3 ;
కోట్ << 'ఒకదానిపై:' < 0 )
కోట్ << ' \n ధన పూర్ణాంకం' ;
లేకపోతే
కోట్ << ' \n ప్రతికూల పూర్ణాంకం!' ;

తిరిగి 0 ;
}

మేము ప్రతికూల పూర్ణాంక విలువతో Int డేటా రకం వేరియబుల్ “num”ని ప్రకటించాము మరియు ప్రారంభించాము. ఆ తరువాత, cout ఆదేశంతో, 'num' విలువ ముద్రించబడుతుంది. అప్పుడు, మనకు if-else షరతు ఉంటుంది. “if” కండిషన్ లోపల, వేరియబుల్ “num” విలువ సున్నా కంటే ఎక్కువగా ఉండాలనే షరతును మేము పేర్కొన్నాము. షరతు నిజమైతే, 'if' కండిషన్ తర్వాత కౌట్ కమాండ్ ముద్రించబడుతుంది. షరతు తప్పుగా మారితే, వేరే కౌట్ స్టేట్‌మెంట్ ముద్రించబడుతుంది.

సంఖ్య ప్రతికూల విలువ అయినందున, if షరతు తప్పుగా మారుతుంది మరియు ది

తరువాత, మేము టెర్నరీ ఆపరేటర్‌తో పై ప్రోగ్రామ్‌ను అమలు చేసాము. if-else కండిషన్ మరియు టెర్నరీ ఆపరేటర్ ఒకే విధమైన ప్రభావాలను కలిగి ఉన్నాయో లేదో తనిఖీ చేద్దాం.

# చేర్చండి

# చేర్చండి

నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;

int ప్రధాన ( ) {

int MyNum = - 7 ;
కోట్ << 'పూర్ణ సంఖ్య:' << MyNum < 0 ) ? 'పాజిటివ్ పూర్ణాంకం!' : 'ప్రతికూల పూర్ణాంకం!' ;
కోట్ << ఫలితం << endl ;

తిరిగి 0 ;
}

మేము వేరియబుల్ “MyNum”ని ప్రకటించాము మరియు దానిని ప్రతికూల విలువతో ప్రారంభించాము. మేము cout కమాండ్ లోపల 'MyNum' వేరియబుల్‌ని కాల్ చేయడం ద్వారా ప్రతికూల విలువను ముద్రించాము. అప్పుడు, మేము స్ట్రింగ్ రకంతో 'ఫలితం' గా మరొక వేరియబుల్ సెట్ చేస్తాము. ఫలితం వేరియబుల్ టెర్నరీ ఆపరేటర్ ఆపరేషన్‌ను తీసుకుంటుంది. ముందుగా, 'MyNum' సున్నా కంటే ఎక్కువగా ఉండాలనే షరతును కలిగి ఉన్నాము. ఆ తరువాత, మేము టెర్నరీ ఆపరేటర్ '?'ని ఉంచాము. పరిస్థితి ఫలితంపై ఇతర రెండు వ్యక్తీకరణలు అమలు చేయబడతాయి.

పూర్ణాంకం విలువ “-7” అయినందున మూడవ వ్యక్తీకరణ, “ప్రతికూల పూర్ణాంకం!” ప్రాంప్ట్‌లో ముద్రించబడింది. ఇక్కడ, రెండు అప్లికేషన్ల నుండి అవుట్‌పుట్ ఒకే విధంగా ఉంటుంది. అయితే, టెర్నరీ ఆపరేటర్ మా కోడ్ యొక్క రీడబిలిటీ మరియు పరిశుభ్రతను మెరుగుపరుస్తుంది.

ఉదాహరణ 3

అదనంగా, టెర్నరీ ఆపరేటర్‌లను ఒకరి లోపల మరొకరు నియమించుకోవచ్చు. కింది ప్రోగ్రామ్‌లో విలువ ధనాత్మకంగా, ప్రతికూలంగా లేదా సున్నాగా ఉందో లేదో తనిఖీ చేయడానికి నెస్టెడ్ టెర్నరీ ఆపరేటర్‌ని ఉపయోగించండి.

# చేర్చండి

# చేర్చండి

నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;

int ప్రధాన ( ) {
int పూర్ణ సంఖ్య = 0 ;
స్ట్రింగ్ ఫలితం ;

ఫలితం = ( పూర్ణ సంఖ్య == 0 ) ? 'సున్నా' : ( ( పూర్ణ సంఖ్య > 0 ) ? 'అనుకూల' : 'ప్రతికూల' ) ;

కోట్ << 'పూర్ణాంకం' << ఫలితం ;

తిరిగి 0 ;
}

ప్రోగ్రామ్ యొక్క ప్రధాన పద్ధతితో ప్రారంభించండి. Int main(), మేము 'పూర్ణాంకం' పేరుతో వేరియబుల్‌ని సృష్టించాము మరియు దాని విలువను సున్నాగా సెట్ చేసాము. అప్పుడు, మేము డేటా టైప్ స్ట్రింగ్‌తో 'ఫలితం' అనే మరొక వేరియబుల్‌ని నిర్వచించాము. మేము దానికి టెర్నరీ ఆపరేటర్‌ను దాటవేస్తూ వేరియబుల్ “ఫలితం” సెట్ చేసాము. షరతు ఏమిటంటే, వేరియబుల్ “పూర్ణాంకం” విలువ సున్నా “పూర్ణాంకం == 0”కి సమానంగా ఉండాలి. ప్రారంభ స్థితి, (పూర్ణాంకం == 0), ఇచ్చిన పూర్ణాంకం సున్నా కాదా అని నిర్ణయిస్తుంది. అలా అయితే, ఫలితం స్ట్రింగ్ విలువ 'సున్నా' ఇవ్వబడుతుంది. సమాధానం సరైనది అయితే. లేకపోతే, మొదటి షరతు తప్పు అయితే, రెండవ షరతు (పూర్ణాంకం > 0) పరిశీలించబడుతుంది.

అవును, స్క్రిప్ట్‌లో చూపిన విధంగా అందించిన పూర్ణాంకం సున్నా. అవుట్‌పుట్ “పూర్ణాంకం జీరో”ని ఉత్పత్తి చేస్తుంది.

ముగింపు

షరతులతో కూడిన ఆపరేటర్ టెర్నరీ ఆపరేటర్ అని మాకు తెలుసు. ఈ ఆపరేటర్ సహాయంతో, మేము ఒక పరిస్థితిని తనిఖీ చేయవచ్చు మరియు దానికి అనుగుణంగా పని చేయవచ్చు. మేము టెర్నరీ ఆపరేటర్‌కు బదులుగా if-else షరతులను ఉపయోగించి అదే పనిని సాధించవచ్చు. ఈ C++ ట్యుటోరియల్ దాని సింటాక్స్ మరియు ఉదాహరణ ప్రోగ్రామ్‌ల ద్వారా టెర్నరీ ఆపరేటర్‌ను ఎలా ఉపయోగించాలో మాకు నేర్పింది. తుది స్టేట్‌మెంట్ క్లుప్తంగా ఉంటేనే టెర్నరీ ఆపరేటర్ తప్పనిసరిగా ఉపయోగించబడుతుందని గుర్తుంచుకోండి.