उदाहरण 1:
कोड यहां 'iostream' हेडर फ़ाइल को शामिल करके शुरू होता है। जैसा कि नाम से पता चलता है, यह हेडर फ़ाइल इनपुट और आउटपुट फ़ंक्शंस के लिए है क्योंकि ये फ़ंक्शंस इसमें घोषित किए गए हैं। फिर, हमारे पास 'नेमस्पेस एसटीडी' है जिसमें इन कार्यों को परिभाषित किया गया है।
इसके नीचे, हम 'मुख्य()' विधि कहते हैं। हम 'int' प्रकार के 'x' वेरिएबल को प्रारंभ करते हैं और इस 'x' को '10' असाइन करते हैं। फिर, हमारे पास 'int' डेटा प्रकार का एक और वेरिएबल, 'y' है और '6' असाइन करें। इसके बाद, हम 'int' डेटा प्रकार के 'r' को आरंभ करते हैं। यहां, हम इन वेरिएबल्स के बीच में '^' ऑपरेटर रखकर 'x' और 'y' वेरिएबल्स के मानों पर 'XOR' ऑपरेशन लागू करते हैं। यह 'XOR' ऑपरेटर पूर्णांक मानों को बाइनरी में परिवर्तित करता है, बाइनरी मानों पर 'XOR' ऑपरेशन लागू करता है, और परिणाम को पूर्णांक मान के रूप में सहेजता है। इस 'XOR' ऑपरेटर का परिणाम अब 'r' में सहेजा गया है।
इसके बाद, हम इन वेरिएबल्स के मानों को अलग-अलग प्रदर्शित करते हैं और फिर 'काउट' की मदद से 'XOR' ऑपरेटर को लागू करने के बाद जो परिणाम मिलता है उसे प्रदर्शित करते हैं।
कोड 1:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( ) {
int यहाँ एक्स = 10 ;
int यहाँ और = 6 ;
int यहाँ आर = एक्स ^ और ;
अदालत << 'x का मान :' << एक्स << अंतः ;
अदालत << 'y का मान :' << और << अंतः ;
अदालत << 'XOR x ^ y = ' << आर << अंतः ;
वापस करना 0 ;
}
आउटपुट:
चूँकि '10' का बाइनरी मान '1010' है और '6' का बाइनरी मान '0110' है, यह 'एक्सओआर' ऑपरेटर को लागू करने के बाद '12' लौटाता है और '1100' '12' का बाइनरी मान है। इससे पता चलता है कि यह '1' लौटाता है जहां दोनों इनपुट अलग-अलग हैं और जहां दोनों इनपुट समान हैं वहां '0' लौटाता है।
उदाहरण 2:
'iostream' हेडर फ़ाइल और 'std' नेमस्पेस जोड़ने के बाद, हम 'main()' विधि को लागू करते हैं। फिर, हम दो वेरिएबल्स, 'X1' और 'X2' को इनिशियलाइज़ करते हैं, और इन वेरिएबल्स को क्रमशः '21' और '35' पूर्णांक मान निर्दिष्ट करते हैं। फिर, हम दोनों वेरिएबल्स के मान प्रिंट करते हैं। इसके बाद, हम इन पूर्णांक मानों पर 'XOR' ऑपरेटर लागू करते हैं। हम इस 'XOR' ऑपरेशन को 'cout' के अंदर इन 'X1' और 'X2' वेरिएबल्स पर लागू करते हैं। तो, इस 'XOR' का परिणाम भी परिणाम के रूप में प्रदर्शित होता है।
कोड 2:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( ) {
int यहाँ X1 = इक्कीस , एक्स2 = 35 ;
अदालत << 'X1 मान = ' << X1 << अंतः ;
अदालत << 'X2 मान = ' << एक्स2 << अंतः ;
अदालत << 'XOR परिणाम है:' << अंतः ;
अदालत << 'X1^X2 = ' << ( X1 ^ एक्स2 ) << अंतः ;
वापस करना 0 ;
}
आउटपुट:
पहला पूर्णांक मान '21' है और दूसरा '35' है। 'XOR' ऑपरेशन लागू करने के बाद, हमें '54' परिणाम मिलता है जो यहां प्रदर्शित होता है।
उदाहरण 3:
हम 'iostream' हेडर फ़ाइल और 'std' नेमस्पेस जोड़ने के बाद 'main()' विधि को कॉल करते हैं। 'Int' प्रकार का 'n1' वेरिएबल प्रारंभ किया गया है और इसे '29' असाइन किया गया है। इसके बाद, हम दूसरे वेरिएबल, 'n2' को '75' निर्दिष्ट करते हैं, जो 'int' डेटा प्रकार का है। इसके बाद, हम 'r1' के साथ-साथ 'int' डेटा प्रकार का मान प्रारंभ करते हैं।
इसके बाद, हम 'n1' और 'n2' वेरिएबल्स के बीच '^' ऑपरेटर रखकर उनके मानों पर 'XOR' ऑपरेशन लागू करते हैं। पूर्णांक मानों को इस 'XOR' ऑपरेटर का उपयोग करके बाइनरी में परिवर्तित किया जाता है जो फिर 'XOR' ऑपरेशन को बाइनरी डेटा पर लागू करता है और परिणाम को पूर्णांक मान के रूप में सहेजता है। 'r1' वेरिएबल में अब इस 'XOR' ऑपरेशन का परिणाम शामिल है। फिर इनमें से प्रत्येक चर का मान अलग-अलग दिखाया गया है। हम 'काउट' ऑपरेटर की सहायता से 'एक्सओआर' ऑपरेटर का उपयोग करने का परिणाम भी दिखाते हैं।
कोड 3:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( )
{
int यहाँ एन 1 = 29 ;
int यहाँ एन 2 = 75 ;
int यहाँ आर 1 = एन 1 ^ एन 2 ;
अदालत << 'पहला मान :' << एन 1 << अंतः ;
अदालत << 'दूसरा मान:' << एन 2 << अंतः ;
अदालत << 'XOR ऑपरेटर का परिणाम है:' << आर 1 << अंतः ;
वापस करना 0 ;
}
आउटपुट:
इनपुट पूर्णांक '29' और '75' हैं जिन्हें बाइनरी में परिवर्तित किया जाता है। फिर, उन पर 'XOR' ऑपरेशन लागू किया जाता है। 'XOR' लगाने के बाद परिणाम '86' है।
उदाहरण 4:
इस कोड में, हम उपयोगकर्ता से इनपुट प्राप्त करते हैं और फिर उपयोगकर्ता के इनपुट मानों पर 'XOR' ऑपरेशन लागू करते हैं। तीन वेरिएबल्स को यहां 'Xvalue1', 'Xvalue2' और 'Xvalue3' नामों से घोषित किया गया है। फिर, हम 'काउट' लगाते हैं और 'यहां दो मान दर्ज करें' संदेश प्रदर्शित करते हैं।
इस संदेश को प्रदर्शित करने के बाद, उपयोगकर्ता उन मानों को दर्ज करता है जो हमें cin की सहायता से मिलते हैं। तो, हम इसके नीचे 'सिन' रखते हैं। दोनों मान अब इन वेरिएबल्स में संग्रहीत हैं और यहां प्रदर्शित भी हैं। अब, हमें 'XOR' ऑपरेशन लागू करना है, इसलिए हम 'Xvalue1' और 'Xvalue2' वेरिएबल्स के बीच '^' ऑपरेटर डालते हैं।
अब, यह 'XOR' ऑपरेशन इन चरों के मानों पर लागू किया जाता है। इस 'XOR' ऑपरेटर का परिणाम फिर 'Xvalue3' वेरिएबल में सहेजा जाता है। हम इसे 'काउट' विधि का उपयोग करके भी प्रदर्शित करते हैं।
कोड 4:
#शामिलनेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( )
{
int यहाँ Xमान 1 , Xमान2 , Xमान3 ;
अदालत << 'यहां दो मान दर्ज करें:' << अंतः ;
अदालत << 'एक्सवैल्यू1:' ;
खाना >> Xमान 1 ;
अदालत << 'एक्सवैल्यू2:' ;
खाना >> Xमान2 ;
Xमान3 = Xमान 1 ^ Xमान2 ;
अदालत << ' \एन अब, दोनों मानों पर XOR लागू करने के बाद: ' << अंतः ;
अदालत << 'एक्सवैल्यू1 ^ एक्सवैल्यू2= ' << Xमान3 << अंतः ;
}
आउटपुट:
जब हम इस कोड को निष्पादित करते हैं, तो यह दो मान दर्ज करने के लिए एक संदेश प्रिंट करता है। इसलिए, हम '14' को 'Xvalue1' वेरिएबल के मान के रूप में और '45' को 'Xvalue2' वेरिएबल के मान के रूप में दर्ज करते हैं। फिर, हम 'एंटर' दबाते हैं। फिर 'XOR' ऑपरेशन इन मानों पर लागू किया जाता है जो दोनों मानों को बाइनरी में परिवर्तित करता है और फिर परिणाम यहां प्रदर्शित करता है।
उदाहरण 5:
हम इस 'XOR' ऑपरेशन को कैरेक्टर डेटा पर लागू करते हैं। हम 'ch_a' और 'ch_b' नामों से दो 'char' वेरिएबल प्रारंभ करते हैं। हम इन वेरिएबल्स को क्रमशः 'ए' और '8' निर्दिष्ट करते हैं। फिर, हम '^' ऑपरेटर को 'ch_a' और 'ch_b' के बीच रखते हैं और इसे 'ch_result' वेरिएबल को असाइन करते हैं जो कि 'char' डेटा प्रकार भी है। इन वर्णों को बाइनरी में बदल दिया जाता है, और परिणाम 'ch_result' वेरिएबल में सहेजा जाता है। फिर हम दोनों वेरिएबल और इस 'XOR' ऑपरेशन के परिणाम को प्रिंट करते हैं।
कोड 5:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( ) {
चार ch_a = 'ए' ;
चार ch_b = '8' ;
चार ch_परिणाम = ch_a ^ ch_b ;
अदालत << 'पहला पात्र है:' << ch_a << अंतः ;
अदालत << 'दूसरा पात्र है:' << ch_b << अंतः ;
अदालत << 'परिणाम है : ' << ch_परिणाम << अंतः ;
}
आउटपुट:
इनपुट अक्षर 'ए' और '8' हैं और 'एक्सओआर' का परिणाम 'वाई' के रूप में प्रदर्शित होता है जो हमें 'एक्सओआर' ऑपरेशन लागू करने के बाद मिलता है जो 'ए' और '8' को बाइनरी में परिवर्तित करता है और फिर 'प्रदर्शन करता है' एक्सओआर” ऑपरेशन।
निष्कर्ष
यहां 'एक्सओआर' ऑपरेशन की पूरी तरह से जांच की गई है और हमने बताया कि यह 'बिटवाइज़' ऑपरेशन है क्योंकि यह बाइनरी मानों का उपयोग करता है। हमने चर्चा की कि 'XOR' ऑपरेशन को लागू करने के लिए हमारे द्वारा दर्ज किए गए सभी मान बाइनरी मानों में परिवर्तित हो जाते हैं, और फिर 'XOR' ऑपरेशन निष्पादित होता है। हमने कई उदाहरण दिखाए और दिखाया कि C++ प्रोग्रामिंग में 'XOR' ऑपरेशन कैसे काम करता है।