C++లో, మేము ఆపరేటర్లతో పని చేస్తున్నప్పుడు, అన్ని కార్యకలాపాలు నిర్వహించబడే క్రమం ఉంది. మా కోడ్ వ్యక్తీకరణలో బహుళ ఆపరేటర్లతో పని చేస్తున్నప్పుడు ఆపరేటర్ ప్రాధాన్యత ఉపయోగించబడుతుంది. ఉదాహరణకు, కూడిక, తీసివేత, గుణకారం మరియు భాగహారం ఆపరేటర్లతో పని చేస్తున్నప్పుడు, గుణకారం మరియు భాగహారం కార్యకలాపాలు అధిక ప్రాధాన్యత ఉన్నందున మొదట ఎడమ నుండి కుడికి నిర్వహించబడతాయి మరియు కూడిక మరియు తీసివేత కార్యకలాపాలు ఎడమ నుండి కుడికి తదుపరి నిర్వహించబడతాయి. గుణకారం మరియు భాగహారం కంటే తక్కువ ప్రాధాన్యత. కానీ వ్యక్తీకరణ కేవలం అదనంగా మరియు తీసివేత ఆపరేటర్లను కలిగి ఉంటే, ఆపరేషన్ కేవలం ఎడమ నుండి కుడికి నిర్వహించబడుతుంది. ఇక్కడ, మేము ఆపరేటర్ ప్రాధాన్యత యొక్క పట్టికను మరియు ఆపరేటర్ ప్రాధాన్యత యొక్క ఉదాహరణలను చూపుతాము.
అంకగణిత కార్యకలాపాల ఆపరేటర్ ప్రాధాన్యత
| ఆపరేషన్ | ఆపరేటర్లు | ప్రాధాన్యత |
|---|---|---|
| కుండలీకరణాలు | () | ఈ కుండలీకరణాలు నిర్వహించబడతాయి. |
| గుణకారం, భాగహారం, మాడ్యులస్ | *, /, % | ఈ కార్యకలాపాలు నిర్వహించబడతాయి మరియు వాటి క్రమం ఎడమ నుండి కుడికి ఉంటుంది. |
| కూడిక, తీసివేత | +, – | ఈ కార్యకలాపాలు చివరిలో నిర్వహించబడతాయి మరియు వాటి క్రమం ఎడమ నుండి కుడికి ఉంటుంది. |
ఉదాహరణ 1:
'iostrem' అనే హెడర్ ఫైల్‌ని చేర్చడం ద్వారా మన కోడ్‌ని ప్రారంభిద్దాం. ఈ “iostream” హెడర్ ఫైల్‌లో అనేక విధులు ప్రకటించబడ్డాయి, వీటిని మనం మా కోడ్‌లో ఉపయోగిస్తాము. దాని క్రింద, మేము “నేమ్‌స్పేస్ std” అని టైప్ చేసి, ముందుకు “ప్రధాన()”ని పిలుస్తాము. ఇక్కడ “main()”లో, “i”, “j” మరియు “k” అనే వేరియబుల్స్‌ని “int”తో ప్రకటిస్తాము మరియు ఇక్కడ మనం పాస్ చేసే విలువలు “10”, “37” మరియు “29”, వరుసగా. మేము ఫలితం సేవ్ చేయబడిన “r” వేరియబుల్‌ను కూడా ప్రకటిస్తాము.
దీని తరువాత, మేము “+, “/” మరియు “-” ఆపరేటర్లను ఉపయోగించి వ్యక్తీకరణను టైప్ చేస్తాము. మేము ఇంతకు ముందు వివరించినట్లుగా, ఈ కార్యకలాపాలు ఒక క్రమంలో నిర్వహించబడతాయి. మేము ఇక్కడ ఉంచిన వ్యక్తీకరణ “i + j / k – j”, దీనిలో మొదట విభజన జరుగుతుంది, ఆపై కూడిక మరియు తీసివేత కార్యకలాపాలు నిర్వహించబడతాయి. మేము “r” వేరియబుల్‌ను పూర్ణాంకం వలె ప్రకటించినప్పుడు ఇది పూర్ణాంక విలువలలో ఫలితాన్ని ప్రదర్శిస్తుంది. కింది వాటిలో, మేము 'కౌట్' ఉపయోగించి కంప్యూటెడ్ ఫలితాన్ని ప్రదర్శిస్తాము.
కోడ్ 1:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
int i = 10 , జె = 37 , కె = 29 , ఆర్ ;
ఆర్ = i + జె / కె - జె ;
కోట్ << 'ఇచ్చిన వ్యక్తీకరణ యొక్క ఫలితం =' << ఆర్ ;
తిరిగి 0 ;
}
అవుట్పుట్:
అన్ని కార్యకలాపాలను నిర్వహించిన తర్వాత అవుట్పుట్ '-26'. ఈ ఫలితం C++ భాష అందించిన ఆపరేటర్ ప్రాధాన్యత ప్రకారం గణించబడుతుంది.
ఉదాహరణ 2:
ఈ కోడ్‌లో, హెడర్ ఫైల్‌ని చేర్చి, “main()”ని ఇన్‌వోక్ చేసిన తర్వాత, మేము “val1” పేరుతో “int” వేరియబుల్‌ని ప్రారంభిస్తాము మరియు “9 + 18 * 7” అని టైప్ చేసే వ్యక్తీకరణను ఉంచుతాము. ఇక్కడ, ఇది మొదట గుణకారాన్ని నిర్వహిస్తుంది మరియు గుణించిన విలువకు “9”ని జోడిస్తుంది. కింది వాటిలో, మేము 'int val2'ని '9 + (18 * 7)'తో ప్రారంభిస్తాము.
ఇక్కడ, కుండలీకరణాలు ముందుగా పరిష్కరించబడతాయి. అప్పుడు, అదనంగా నిర్వహిస్తారు. దీని తరువాత, మేము '(9 + 18) * 7' వ్యక్తీకరణతో 'int val3'ని కూడా ప్రారంభిస్తాము. ఈ వ్యక్తీకరణలో, కుండలీకరణాలు మళ్లీ మొదట నిర్వహించబడతాయి మరియు తరువాత గుణకారం నిర్వహించబడుతుంది. వ్యక్తీకరణ విలువలు ఒకే విధంగా ఉంటాయి కానీ ఆపరేటర్ ప్రాధాన్యత కారణంగా అవి ప్రత్యేకమైన ఫలితాలను అందిస్తాయి. ఇప్పుడు, మేము ముందుకు వెళ్తాము మరియు 'val1', 'val2' మరియు 'val3' వేరియబుల్స్లో నిల్వ చేయబడిన అన్ని ఫలితాలను 'cout' సహాయంతో ప్రింట్ చేస్తాము.
కోడ్ 2:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
int ఎంపిక 1 = 9 + 18 * 7 ;
int విలువ 2 = 9 + ( 18 * 7 ) ;
int విలువ 3 = ( 9 + 18 ) * 7 ;
కోట్ << 'మొదటి ఫలితం చూపిస్తుంది =' << ఎంపిక 1 << endl ;
కోట్ << 'రెండవ ఫలితం చూపిస్తుంది =' << విలువ 2 << endl ;
కోట్ << 'మూడవ ఫలితం చూపిస్తుంది =' << విలువ 3 << endl ;
తిరిగి 0 ;
}
అవుట్పుట్:
ఇచ్చిన వ్యక్తీకరణను గణించిన తర్వాత మనకు లభించే ఫలితం క్రింది విధంగా ఉంటుంది. విలువలు ఒకే విధంగా ఉన్నప్పటికీ, మూడవ ఫలితం మిగిలిన రెండింటికి సమానంగా లేదని మనం చూడవచ్చు. ఎక్స్‌ప్రెషన్ ఆపరేటర్‌కు వర్తించే ఆపరేటర్ ప్రాధాన్యత దీనికి కారణం.
ఉదాహరణ 3:
ఇక్కడ, మేము వేర్వేరు విలువలతో విభిన్న వేరియబుల్‌లను ప్రారంభిస్తాము మరియు ఈ అన్ని వేరియబుల్స్ యొక్క డేటా రకం “int”. మనకు వరుసగా “14”, “9”, “15” మరియు “29” విలువలతో “a”, “b”, “c” మరియు “d” అనే పూర్ణాంక వేరియబుల్స్ ఉన్నాయి. దీని తర్వాత, మేము “int R1”ని ప్రారంభిస్తాము మరియు ఇక్కడ మనం ఉంచే వ్యక్తీకరణ “a + b) * c / d”. కుండలీకరణాలు ముందుగా పరిష్కరించబడతాయి. అప్పుడు, గుణకారం మరియు విభజన కార్యకలాపాలు నిర్వహిస్తారు. మేము దీని క్రింద ఫలితాన్ని కూడా ప్రదర్శిస్తాము. అప్పుడు, మనకు “a – b * (d + a) + c” వ్యక్తీకరణతో “int R2” ఉంటుంది. ఇక్కడ, ఇది కుండలీకరణాలను కూడా పరిష్కరిస్తుంది, ఆపై వ్యవకలనం మరియు కూడికలు ఆపరేటర్ ప్రాధాన్యత ప్రకారం నిర్వహించబడతాయి. మేము దాని ఫలితాన్ని కూడా ప్రింట్ చేస్తాము మరియు “b – d + c * a” ఎక్స్‌ప్రెషన్ టైప్ చేయబడిన “int R3”ని ప్రారంభిస్తాము. ఈ వ్యక్తీకరణలో, ముందుగా గుణకారం నిర్వహించబడుతుంది, తరువాత వ్యవకలనం మరియు కూడిక నిర్వహించబడుతుంది. ఈ వ్యక్తీకరణ యొక్క ఫలితం క్రింది వాటిలో కూడా ప్రదర్శించబడుతుంది. ఇప్పుడు, మనకు చివరి వ్యక్తీకరణ, “d + (a * b) / a” ఉంది, దీని ఫలితం “R4” వేరియబుల్‌లో నిల్వ చేయబడుతుంది. ఈ వ్యక్తీకరణలో, కుండలీకరణాలు మొదట పరిష్కరించబడతాయి మరియు తరువాత విభజించబడతాయి. ముగింపులో, అదనంగా నిర్వహిస్తారు. ఈ వ్యక్తీకరణ యొక్క ఫలితం క్రింది విధంగా చూపబడింది:
కోడ్ 3:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
int a = 14 ;
int బి = 9 ;
int సి = పదిహేను ;
int డి = 29 ;
int R1 = ( a + బి ) * సి / డి ;
కోట్ << '(a + b) * c / d ' << 'ఇస్తుంది =' << R1 << endl ;
int R2 = a - బి * ( డి + a ) + సి ;
కోట్ << 'a - b (d + a) + c ' << 'ఇస్తుంది =' << R2 << endl ;
int R3 = బి - డి + సి * a ;
కోట్ << 'b - d + c * a ' << 'ఇస్తుంది =' << R3 << endl ;
int R4 = డి + ( a * బి ) / a ;
కోట్ << 'd + (a * b) / a ' << 'ఇస్తుంది =' << R4 << endl ;
తిరిగి 0 ;
}
అవుట్పుట్:
మునుపు పేర్కొన్న వ్యక్తీకరణలను గణించడం యొక్క ఫలితం క్రిందిది. ఎక్స్‌ప్రెషన్‌లోని ఆపరేటర్లు ఆపరేటర్ ప్రాధాన్యతను వారికి వర్తింపజేసారు కాబట్టి మేము ఈ ఫలితాన్ని పొందుతాము:
ఉదాహరణ 4:
మేము ఇక్కడ “a1”, “b1”, “c1”, “d1”, “e1” మరియు “f1” వేరియబుల్స్‌ని “64”, “90”, “11”, “27” పూర్ణాంక విలువలతో ప్రారంభిస్తాము, వరుసగా '34' మరియు '98'. మేము ఇక్కడ “int result1”ని “a1 + b1 – c1) * d1 / f1” ఎక్స్‌ప్రెషన్‌తో ప్రారంభిస్తాము మరియు ఫలితం “ఫలితం1” వేరియబుల్‌లో నిల్వ చేయబడుతుంది. ఇక్కడ, కుండలీకరణాలు ముందుగా పరిష్కరించబడతాయి. అప్పుడు, మిగిలిన కార్యకలాపాలు వరుసగా గణించబడతాయి. అప్పుడు, మేము 'ఫలితం1' ను ప్రింట్ చేస్తాము. అదే విధంగా, మేము వ్యక్తీకరణలను గణిస్తాము మరియు వాటిని వివిధ వేరియబుల్స్లో నిల్వ చేస్తాము. అప్పుడు, ఆపరేటర్ ప్రాధాన్యత ఎలా పనిచేస్తుందో చూపిస్తూ, మేము అన్ని ఫలితాలను విడిగా ప్రింట్ చేస్తాము.
కోడ్ 4:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
int a1 = 64 ;
int b1 = 90 ;
int c1 = పదకొండు ;
int d1 = 27 ;
int ఇ1 = 3. 4 ;
int f1 = 98 ;
int ఫలితం1 = ( a1 + b1 - c1 ) * d1 / f1 ;
కోట్ << 'ఫలితం 1' << ఫలితం1 << endl ;
int ఫలితం2 = a1 + ( f1 * b1 ) / ఇ1 ;
కోట్ << 'ఫలితం 2' << ఫలితం2 << endl ;
int ఫలితం3 = ఇ1 + d1 + a1 - c1 * b1 / a1 ;
కోట్ << 'ఫలితం 3' << ఫలితం3 << endl ;
int ఫలితం4 = a1 - f1 + ( b1 - d1 ) * c1 ;
కోట్ << 'ఫలితం 4' << ఫలితం4 << endl ;
int ఫలితం5 = ( f1 + ( a1 * ( b1 + a1 ) - f1 ) * a1 + ఇ1 ) ;
కోట్ << 'ఫలితం 5' << ఫలితం5 << endl ;
తిరిగి 0 ;
}
అవుట్పుట్:
ఇచ్చిన కోడ్ యొక్క అవుట్పుట్ ఇక్కడ రెండర్ చేయబడింది, ఇది మనం గతంలో నమోదు చేసిన అన్ని వ్యక్తీకరణల ఫలితాన్ని చూపుతుంది. అన్ని వ్యక్తీకరణలు ఆర్డర్ ప్రాధాన్యత నియమాన్ని అనుసరించడం ద్వారా గణించబడతాయి.
ముగింపు
మేము ఇక్కడ 'C++ ప్రాధాన్యత'ని చూశాము, దీనిలో C++ ప్రోగ్రామింగ్‌లో గణించబడే ఆపరేటర్ల క్రమాన్ని మేము లోతుగా అధ్యయనం చేసాము. మేము ఆపరేటర్ల క్రమాన్ని కూడా టేబుల్ రూపంలో చూపించాము మరియు C++ ప్రోగ్రామింగ్‌లో ఆర్డర్ ప్రాధాన్యత ప్రకారం వ్యక్తీకరణలు ఎలా పరిష్కరించబడతాయో తెలుసుకున్న అనేక ఉదాహరణలను ప్రదర్శించాము.