लॉजिकल ऑपरेटर ( ||
और &&
) बनाम बिटवाइज़ ऑपरेटर ( |
और &
)।
एक तार्किक ऑपरेटर और बिटवाइज़ ऑपरेटर के बीच सबसे महत्वपूर्ण अंतर यह है कि एक तार्किक ऑपरेटर दो बूलियन लेता है और एक बूलियन का उत्पादन करता है जबकि एक बिटवाइज़र ऑपरेटर दो पूर्णांक लेता है और एक पूर्णांक बनाता है (ध्यान दें: पूर्णांक का अर्थ है किसी भी अभिन्न डेटा प्रकार, न कि केवल इंट)।
पांडित्यपूर्ण होने के लिए, एक बिटवाइज़ ऑपरेटर एक बिट-पैटर्न (जैसे 01101011) लेता है और प्रत्येक बिट के लिए एक बिट-वार और / या करता है। उदाहरण के लिए, यदि आपके पास दो 8-बिट पूर्णांक हैं:
a = 00110010 (in decimal: 32+16+2 = 50)
b = 01010011 (in decimal: 64+ 16+2+1 = 83)
----------------
a & b = 00010010 (in decimal: 16+2 = 18)
a | b = 01110011 (in decimal: 64+32+16+2+1 = 115)
जबकि एक तार्किक ऑपरेटर केवल इसमें काम करता है bool
:
a = true
b = false
--------------
a && b = false
a || b = true
दूसरा, अक्सर बूल पर एक बिटवाइज़ ऑपरेटर का उपयोग करना संभव होता है क्योंकि सच्चा और गलत क्रमशः 1 और 0 के बराबर होता है, और ऐसा होता है कि यदि आप सच्चे 1 का अनुवाद करते हैं और 0 से झूठ बोलते हैं, तो बिटवाइज़ ऑपरेशन करें, फिर नॉन-जीरो कन्वर्ट करें सच और शून्य से झूठ; ऐसा होता है कि परिणाम वही होगा जिसमें आपने तार्किक ऑपरेटर का उपयोग किया था (व्यायाम के लिए इसे देखें)।
एक अन्य महत्वपूर्ण अंतर यह भी है कि एक तार्किक ऑपरेटर कम परिचालित होता है । इस प्रकार, कुछ मंडलियों में [1], आप अक्सर लोगों को कुछ ऐसा करते हुए देखते हैं:
if (person && person.punch()) {
person.doVictoryDance()
}
जो अनुवाद करता है: "यदि व्यक्ति मौजूद है (अर्थात अशक्त नहीं है), तो उसे पंच करने की कोशिश करें, और यदि पंच सफल होता है (यानी सच लौटाता है), तो एक विजय नृत्य करें" ।
क्या आपने इसके बजाय बिटकॉइन ऑपरेटर का उपयोग किया था:
if (person & person.punch()) {
person.doVictoryDance()
}
में अनुवाद होगा: "यदि व्यक्ति मौजूद है (अर्थात अशक्त नहीं है) और पंच सफल होता है (यानी सही रिटर्न देता है), तो एक विजय नृत्य करें" ।
ध्यान दें कि शॉर्ट-सर्कुलेटेड लॉजिकल ऑपरेटर में, person.punch()
कोड person
शून्य होने पर बिल्कुल भी नहीं चलाया जा सकता है। वास्तव में, इस विशेष मामले में, दूसरा कोड एक अशक्त संदर्भ त्रुटि पैदा करेगा यदि person
अशक्त है, क्योंकि यह person.punch()
किसी भी व्यक्ति को कॉल करने की कोशिश करता है चाहे वह अशक्त हो या नहीं। सही ऑपरेंड का मूल्यांकन नहीं करने के इस व्यवहार को शॉर्ट-सर्क्युटिंग कहा जाता है ।
[१] कुछ प्रोग्रामर एक फंक्शन कॉल लगाने के लिए बोलेंगे जो एक if
अभिव्यक्ति के अंदर एक साइड इफेक्ट है , जबकि अन्य के लिए यह एक सामान्य और बहुत उपयोगी मुहावरा है।
चूँकि एक बिटवाइज़ ऑपरेटर एक बार में 32-बिट्स पर काम करता है (यदि आप 32-बिट मशीन पर हैं), तो यह अधिक सुंदर और तेज़ कोड को जन्म दे सकता है, यदि आपको बहुत अधिक परिस्थितियों की तुलना करने की आवश्यकता है, जैसे।
int CAN_PUNCH = 1 << 0, CAN_KICK = 1 << 1, CAN_DRINK = 1 << 2, CAN_SIT = 1 << 3,
CAN_SHOOT_GUNS = 1 << 4, CAN_TALK = 1 << 5, CAN_SHOOT_CANNONS = 1 << 6;
Person person;
person.abilities = CAN_PUNCH | CAN_KICK | CAN_DRINK | CAN_SIT | CAN_SHOOT_GUNS;
Place bar;
bar.rules = CAN_DRINK | CAN_SIT | CAN_TALK;
Place military;
military.rules = CAN_SHOOT_CANNONS | CAN_PUNCH | CAN_KICK | CAN_SHOOT_GUNS | CAN_SIT;
CurrentLocation cloc1, cloc2;
cloc1.usable_abilities = person_abilities & bar_rules;
cloc2.usable_abilities = person_abilities & military_rules;
// cloc1.usable_abilities will contain the bit pattern that matches `CAN_DRINK | CAN_SIT`
// while cloc2.usable_abilities will contain the bit pattern that matches `CAN_PUNCH | CAN_KICK | CAN_SHOOT_GUNS | CAN_SIT`
तार्किक ऑपरेटरों के साथ ऐसा करने के लिए तुलना की अजीब मात्रा की आवश्यकता होगी:
Person person;
person.can_punch = person.can_kick = person.can_drink = person.can_sit = person.can_shoot_guns = true;
person.can_shoot_cannons = false;
Place bar;
bar.rules.can_drink = bar.rules.can_sit = bar.rules.can_talk = true;
bar.rules.can_punch = bar.rules.can_kick = bar.rules.can_shoot_guns = bar.rules.can_shoot_cannons = false;
Place military;
military.rules.can_punch = military.rules.can_kick = military.rules.can_shoot_guns = military.rules.can_shoot_cannons = military.rules.can_sit = true;
military.rules.can_drink = military.rules.can_talk = false;
CurrentLocation cloc1;
bool cloc1.usable_abilities.can_punch = bar.rules.can_punch && person.can_punch,
cloc1.usable_abilities.can_kick = bar.rules.can_kick && person.can_kick,
cloc1.usable_abilities.can_drink = bar.rules.can_drink && person.can_drink,
cloc1.usable_abilities.can_sit = bar.rules.can_sit && person.can_sit,
cloc1.usable_abilities.can_shoot_guns = bar.rules.can_shoot_guns && person.can_shoot_guns,
cloc1.usable_abilities.can_shoot_cannons = bar.rules.can_shoot_cannons && person.can_shoot_cannons
cloc1.usable_abilities.can_talk = bar.rules.can_talk && person.can_talk;
bool cloc2.usable_abilities.can_punch = military.rules.can_punch && person.can_punch,
cloc2.usable_abilities.can_kick = military.rules.can_kick && person.can_kick,
cloc2.usable_abilities.can_drink = military.rules.can_drink && person.can_drink,
cloc2.usable_abilities.can_sit = military.rules.can_sit && person.can_sit,
cloc2.usable_abilities.can_shoot_guns = military.rules.can_shoot_guns && person.can_shoot_guns,
cloc2.usable_abilities.can_talk = military.rules.can_talk && person.can_talk,
cloc2.usable_abilities.can_shoot_cannons = military.rules.can_shoot_cannons && person.can_shoot_cannons;
एक शास्त्रीय उदाहरण जहां बिट-पैटर्न और बिटवाइज़ ऑपरेटर का उपयोग किया जाता है, वह यूनिक्स / लिनक्स फ़ाइल सिस्टम अनुमतियों में है।