ఉదాహరణ 1:
'iostream' హెడర్ ఫైల్‌ని చేర్చడం ద్వారా కోడ్ ఇక్కడ ప్రారంభమవుతుంది. పేరు సూచించినట్లుగా, ఈ హెడర్ ఫైల్ ఇన్‌పుట్ మరియు అవుట్‌పుట్ ఫంక్షన్‌ల కోసం ఉద్దేశించబడింది, ఎందుకంటే ఈ ఫంక్షన్‌లు ఇందులో ప్రకటించబడ్డాయి. అప్పుడు, ఈ ఫంక్షన్‌లు నిర్వచించబడిన “నేమ్‌స్పేస్ std”ని కలిగి ఉన్నాము.
దీని క్రింద, మేము 'ప్రధాన ()' పద్ధతిని పిలుస్తాము. మేము 'int' రకం యొక్క 'x' వేరియబుల్‌ని ప్రారంభించాము మరియు ఈ 'x'కి '10'ని కేటాయిస్తాము. అప్పుడు, మనకు “int” డేటా రకం యొక్క మరొక వేరియబుల్ “y” ఉంది మరియు “6”ని కేటాయించండి. దీని తరువాత, మేము 'int' డేటా రకం యొక్క 'r'ని ప్రారంభిస్తాము. ఇక్కడ, మేము ఈ వేరియబుల్స్ మధ్య “^” ఆపరేటర్‌ని ఉంచడం ద్వారా “x” మరియు “y” వేరియబుల్స్ విలువలపై “XOR” ఆపరేషన్‌ను వర్తింపజేస్తాము. ఈ “XOR” ఆపరేటర్ పూర్ణాంక విలువలను బైనరీలోకి మారుస్తుంది, బైనరీ విలువలపై “XOR” ఆపరేషన్‌ను వర్తింపజేస్తుంది మరియు ఫలితాన్ని పూర్ణాంక విలువగా సేవ్ చేస్తుంది. ఈ “XOR” ఆపరేటర్ యొక్క ఫలితం ఇప్పుడు “r”లో సేవ్ చేయబడింది.
దీని తరువాత, మేము ఈ వేరియబుల్స్ యొక్క విలువలను విడిగా ప్రదర్శిస్తాము మరియు 'కౌట్' సహాయంతో 'XOR' ఆపరేటర్‌ను వర్తింపజేసిన తర్వాత మనకు లభించే ఫలితాన్ని ప్రదర్శిస్తాము.
కోడ్ 1:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int x = 10 ;
int మరియు = 6 ;
int ఆర్ = x ^ మరియు ;
కోట్ << 'x విలువ :' << x << endl ;
కోట్ << 'y విలువ :' << మరియు << endl ;
కోట్ << 'XOR x ^ y =' << ఆర్ << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
“10” యొక్క బైనరీ విలువ “1010” మరియు “6” యొక్క బైనరీ విలువ “0110” కాబట్టి, ఇది “XOR” ఆపరేటర్‌ని వర్తింపజేసిన తర్వాత “12”ని అందిస్తుంది మరియు “1100” అనేది “12” యొక్క బైనరీ విలువ. ఇది రెండు ఇన్‌పుట్‌లు వేర్వేరుగా ఉన్న చోట “1”ని అందిస్తుంది మరియు రెండు ఇన్‌పుట్‌లు ఒకేలా ఉన్న “0”ని అందిస్తుంది.
ఉదాహరణ 2:
“iostream” హెడర్ ఫైల్ మరియు “std” నేమ్‌స్పేస్‌ని జోడించిన తర్వాత, మేము “main()” పద్ధతిని అమలు చేస్తాము. అప్పుడు, మేము “X1” మరియు “X2” అనే రెండు వేరియబుల్‌లను ప్రారంభిస్తాము మరియు ఈ వేరియబుల్స్‌కు వరుసగా “21” మరియు “35” పూర్ణాంక విలువలను కేటాయిస్తాము. అప్పుడు, మేము రెండు వేరియబుల్స్ విలువలను ప్రింట్ చేస్తాము. దీని తర్వాత, మేము ఈ పూర్ణాంక విలువలకు “XOR” ఆపరేటర్‌ని వర్తింపజేస్తాము. మేము ఈ “XOR” ఆపరేషన్‌ని “కౌట్” లోపల ఈ “X1” మరియు “X2” వేరియబుల్స్‌కి వర్తింపజేస్తాము. కాబట్టి, ఈ “XOR” ఫలితం కూడా ఫలితంగా ప్రదర్శించబడుతుంది.
కోడ్ 2:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int X1 = ఇరవై ఒకటి , X2 = 35 ;
కోట్ << 'X1 విలువ =' << X1 << endl ;
కోట్ << 'X2 విలువ =' << X2 << endl ;
కోట్ << 'XOR ఫలితం:' << endl ;
కోట్ << 'X1^X2 =' << ( X1 ^ X2 ) << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
మొదటి పూర్ణాంకం విలువ '21' మరియు రెండవది '35'. “XOR” ఆపరేషన్‌ని వర్తింపజేసిన తర్వాత, ఇక్కడ ప్రదర్శించబడే “54” ఫలితం మనకు వస్తుంది.
ఉదాహరణ 3:
మేము “iostream” హెడర్ ఫైల్ మరియు “std” నేమ్‌స్పేస్‌ని జోడించిన తర్వాత “main()” పద్ధతిని పిలుస్తాము. “int” రకం యొక్క “n1” వేరియబుల్ ప్రారంభించబడింది మరియు దానికి “29” కేటాయించబడింది. తరువాత, మేము '75'ని మరొక వేరియబుల్, 'n2'కి కేటాయిస్తాము, ఇది 'int' డేటా రకం. తరువాత, మేము “r1″ అలాగే “int” డేటా రకం విలువను ప్రారంభిస్తాము.
తరువాత, మేము 'n1' మరియు 'n2' వేరియబుల్స్ మధ్య '^' ఆపరేటర్‌ను ఉంచడం ద్వారా వాటి విలువలపై 'XOR' ఆపరేషన్‌ను వర్తింపజేస్తాము. పూర్ణాంక విలువలు ఈ “XOR” ఆపరేటర్‌ని ఉపయోగించి బైనరీకి మార్చబడతాయి, అది బైనరీ డేటాకు “XOR” ఆపరేషన్‌ను వర్తింపజేస్తుంది మరియు ఫలితాన్ని పూర్ణాంక విలువగా సేవ్ చేస్తుంది. “r1” వేరియబుల్ ఇప్పుడు ఈ “XOR” ఆపరేషన్ ఫలితాన్ని కలిగి ఉంది. ఈ వేరియబుల్స్‌లోని ప్రతి విలువలు విడిగా చూపబడతాయి. మేము 'కౌట్' ఆపరేటర్ సహాయంతో 'XOR' ఆపరేటర్‌ను ఉపయోగించడం యొక్క ఫలితాన్ని కూడా చూపుతాము.
కోడ్ 3:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
int n1 = 29 ;
int n2 = 75 ;
int r1 = n1 ^ n2 ;
కోట్ << 'మొదటి విలువ :' << n1 << endl ;
కోట్ << 'రెండవ విలువ :' << n2 << endl ;
కోట్ << 'XOR ఆపరేటర్ యొక్క ఫలితం:' << r1 << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇన్‌పుట్ పూర్ణాంకాలు “29” మరియు “75” బైనరీగా మార్చబడతాయి. అప్పుడు, 'XOR' ఆపరేషన్ వారికి వర్తించబడుతుంది. “XOR”ని వర్తింపజేసిన తర్వాత, ఫలితం “86”.
ఉదాహరణ 4:
ఈ కోడ్‌లో, మేము వినియోగదారు నుండి ఇన్‌పుట్‌ను పొందుతాము మరియు వినియోగదారు ఇన్‌పుట్ విలువలకు “XOR” ఆపరేషన్‌ను వర్తింపజేస్తాము. మూడు వేరియబుల్స్ ఇక్కడ “Xvalue1”, “Xvalue2” మరియు “Xvalue3” పేర్లతో ప్రకటించబడ్డాయి. అప్పుడు, మేము 'కౌట్' ను ఉంచుతాము మరియు 'ఇక్కడ రెండు విలువలను నమోదు చేయండి' సందేశాన్ని ప్రదర్శిస్తాము.
ఈ సందేశాన్ని ప్రదర్శించిన తర్వాత, వినియోగదారు సిన్ సహాయంతో మనకు లభించే విలువలను నమోదు చేస్తారు. కాబట్టి, మేము దీని క్రింద 'సిన్' ఉంచుతాము. రెండు విలువలు ఇప్పుడు ఈ వేరియబుల్స్‌లో నిల్వ చేయబడ్డాయి మరియు ఇక్కడ కూడా ప్రదర్శించబడతాయి. ఇప్పుడు, మనం “XOR” ఆపరేషన్‌ని వర్తింపజేయాలి, కాబట్టి మనం “Xvalue1” మరియు “Xvalue2” వేరియబుల్స్ మధ్య “^” ఆపరేటర్‌ని ఇన్సర్ట్ చేస్తాము.
ఇప్పుడు, ఈ 'XOR' ఆపరేషన్ ఈ వేరియబుల్స్ విలువలకు వర్తించబడుతుంది. ఈ “XOR” ఆపరేటర్ యొక్క ఫలితం అప్పుడు “Xvalue3” వేరియబుల్‌లో సేవ్ చేయబడుతుంది. మేము దానిని 'కౌట్' పద్ధతిని ఉపయోగించి కూడా ప్రదర్శిస్తాము.
కోడ్ 4:
#includeనేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
int X విలువ 1 , Xvalue2 , Xvalue3 ;
కోట్ << 'విలువలు రెండు విలువలను ఇక్కడ నమోదు చేయండి:' << endl ;
కోట్ << 'Xvalue1:' ;
ఆహారపు >> X విలువ 1 ;
కోట్ << 'Xvalue2:' ;
ఆహారపు >> Xvalue2 ;
Xvalue3 = X విలువ 1 ^ Xvalue2 ;
కోట్ << ' \n ఇప్పుడు, రెండు విలువలపై XORని వర్తింపజేసిన తర్వాత: ' << endl ;
కోట్ << 'Xvalue1 ^ Xvalue2 = ' << Xvalue3 << endl ;
}
అవుట్‌పుట్:
మేము ఈ కోడ్‌ని అమలు చేసినప్పుడు, ఇది రెండు విలువలను నమోదు చేయడానికి సందేశాన్ని ముద్రిస్తుంది. కాబట్టి, మనం “14”ని “Xvalue1” వేరియబుల్ విలువగా మరియు “45”ని “Xvalue2” వేరియబుల్ విలువగా నమోదు చేస్తాము. అప్పుడు, మేము 'Enter' నొక్కండి. 'XOR' ఆపరేషన్ ఈ విలువలకు వర్తించబడుతుంది, ఇది రెండు విలువలను బైనరీగా మారుస్తుంది మరియు ఫలితాన్ని ఇక్కడ ప్రదర్శిస్తుంది.
ఉదాహరణ 5:
మేము ఈ “XOR” ఆపరేషన్‌ని అక్షర డేటాకు వర్తింపజేస్తాము. మేము 'ch_a' మరియు 'ch_b' పేర్లతో రెండు 'char' వేరియబుల్‌లను ప్రారంభిస్తాము. మేము ఈ వేరియబుల్స్‌కు వరుసగా “a” మరియు “8” లను కేటాయిస్తాము. అప్పుడు, మేము “^” ఆపరేటర్‌ను “ch_a” మరియు “ch_b” మధ్య ఉంచి, దానిని “char” డేటా రకం అయిన “ch_result” వేరియబుల్‌కి కేటాయిస్తాము. ఈ అక్షరాలు బైనరీగా మార్చబడతాయి మరియు ఫలితం “ch_result” వేరియబుల్‌లో సేవ్ చేయబడుతుంది. మేము రెండు వేరియబుల్స్ మరియు ఈ 'XOR' ఆపరేషన్ ఫలితాన్ని ముద్రిస్తాము.
కోడ్ 5:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
చార్ ch_a = 'a' ;
చార్ ch_b = '8' ;
చార్ ch_ఫలితం = ch_a ^ ch_b ;
కోట్ << 'మొదటి పాత్ర:' << ch_a << endl ;
కోట్ << 'రెండవ పాత్ర:' << ch_b << endl ;
కోట్ << 'ఫలితం:' << ch_ఫలితం << endl ;
}
అవుట్‌పుట్:
ఇన్‌పుట్ అక్షరాలు “a” మరియు “8” మరియు “XOR” ఫలితం “Y”గా ప్రదర్శించబడుతుంది, ఇది “a” మరియు “8”లను బైనరీగా మార్చే “XOR” ఆపరేషన్‌ను వర్తింపజేసిన తర్వాత మనకు లభిస్తుంది మరియు “ XOR' ఆపరేషన్.
ముగింపు
“XOR” ఆపరేషన్ ఇక్కడ క్షుణ్ణంగా అన్వేషించబడింది మరియు బైనరీ విలువలను వినియోగిస్తున్నందున ఇది “బిట్‌వైస్” ఆపరేషన్ అని మేము వివరించాము. 'XOR' ఆపరేషన్‌ను వర్తింపజేయడానికి మేము నమోదు చేసిన అన్ని విలువలు బైనరీ విలువలుగా మార్చబడి, ఆపై 'XOR' ఆపరేషన్ నిర్వహించబడుతుందని మేము చర్చించాము. మేము అనేక ఉదాహరణలను ప్రదర్శించాము మరియు C++ ప్రోగ్రామింగ్‌లో “XOR” ఆపరేషన్ ఎలా పనిచేస్తుందో చూపించాము.