क्यों और दो नंबर एक बूलियन प्राप्त करने के लिए?

Question

मैं वेलेमैन के 8055 बोर्ड के आधार पर एक छोटी हार्डवेयर इंटरफेस परियोजना पर काम कर रहा हूं।

उदाहरण कोड VB.Net में आता है और मैं इसे सी # में फिर से लिख रहा हूं, अधिकांशतः कोड के माध्यम से कदम उठाने और इसे समझने का मौका पाने के लिए।

एक बात मुझे हालांकि चकित कर दिया है:

एक चरण में वे सभी डिजिटल आदानों पढ़ें और फिर पढ़ा डिजिटल आदानों (जो एक पूर्णांक में वापस आने के लिए) के लिए उत्तर के आधार पर एक चेकबॉक्स सेट और फिर वे और इस एक संख्या के साथ:

i = ReadAllDigital 
cbi(1).Checked = (i And 1) 
cbi(2).Checked = (i And 2) \ 2 
cbi(3).Checked = (i And 4) \ 4 
cbi(4).Checked = (i And 8) \ 8 
cbi(5).Checked = (i And 16) \ 16 

मैं एक समय में एक डिजिटल सिस्टम नहीं किया है और मैं समझता हूँ कि वे क्या करने की कोशिश कर रहे हैं, लेकिन क्या प्रभाव यह और दो नंबर करने के लिए होगा? क्या 0 से ऊपर सब कुछ सच नहीं है?

आप इसे सी # में कैसे अनुवादित करेंगे?

Answer 1

मैं आपको लगता है सब कुछ कम करने के लिए 'यह करने के लिए इसका अनुवाद करना होगा:

i & 1 == 1 

i & 2 == 2 

i & 4 == 4 

आदि ... यह बिटवाइज़ उपयोग कर रहा है और ऑपरेटर।

जब आप बिटवाई और ऑपरेटर का उपयोग करते हैं, तो यह ऑपरेटर दो दिए गए मानों के द्विआधारी प्रतिनिधित्व की तुलना करेगा, और एक द्विआधारी मूल्य लौटाएगा जहां केवल उन बिट्स सेट हैं, जो दो ऑपरेटरों में भी सेट हैं।

उदाहरण के लिए

, जब आप ऐसा करते हैं:

यह ऐसा करेंगे:

0010 & 0010 

और यह परिणाम होगा में:

0010 
0010 
&---- 
0010 

तो अगर आप इस परिणाम की तुलना 2 (0010) के साथ करते हैं, यह सचमुच वापस आ जाएगा।

Answer 2

यह bitwise AND कर रहा है, तार्किक नहीं है और।

उन में से प्रत्येक मूल रूप से i में एक भी बिट उदाहरण के लिए, सेट कर दिया जाता है कि क्या निर्धारित करता है:

5 AND 4 = 4 
5 AND 2 = 0 
5 AND 1 = 1 

(क्योंकि 5 = द्विआधारी 101, और 4, 2 और 1 द्विआधारी 100 के दशमलव मान होते हैं, 010 और क्रमशः 001।)

Answer 3

बाइनरी उदाहरण में इस बारे में सोचें

10101010 

AND 

00000010 

पैदावार 00000010

अर्थात नहीं शून्य। अब अगर पहले मूल्य

10101000 

था आप

00000000 

अर्थात शून्य मिल चाहते हैं।

नोट आगे विभाजन करने के लिए 1 या 0.

Answer 4

(i और 16)/16 5 वें बिट के मान (1 या 0) को निकालता है।

1xxxx and 16 = 16/16 = 1 
0xxxx and 16 = 0/16 = 0 

Answer 5

And ऑपरेटर प्रदर्शन "दो सांख्यिक भाव पर ... बिटवाइज़ संयोजन" है, जो करने के लिए नक्शे '|' सी # में '`integer division है, और सी # में समतुल्य / है, बशर्ते कि दोनों ऑपरेंड पूर्णांक प्रकार हों।

Answer 6

निरंतर संख्या masks (बाइनरी में उनके बारे में सोचें) हैं। तो बिट प्राप्त करने के लिए कोड क्या करता है bitwise AND ऑपरेटर बाइट और मास्क पर और संख्या से विभाजित करता है।

उदाहरण के लिए:

xxxxxxxx & 00000100 = 00000x000 
if x == 1 
    00000x00/00000100 = 000000001 
else if x == 0 
    00000x00/00000100 = 000000000 

Answer 7

के रूप में कहा कि यह एक बिटवाइज़ एक तार्किक नहीं है और, और। मैं देखता हूं कि यह मेरे सामने कुछ बार कहा गया है, लेकिन आईएमओ स्पष्टीकरण को समझना इतना आसान नहीं है।

मैं इस तरह इसके बारे में सोचना पसंद:

एक दूसरे के तहत द्विआधारी संख्या ऊपर लिखें (यहाँ मैं 5 कर रहा हूँ और 1):

101 
001 

अब हम में इस चालू करने की आवश्यकता एक द्विआधारी संख्या है, जहां सभी 1 1 नंबर से की, कि एक दूसरे में भी है हस्तांतरित हो जाता है, वह यह है कि - इस मामले में:

001 

इस मामले में हम इसे 2 के रूप में एक ही नंबर देता है देखना संख्या, i n जो यह ऑपरेशन (वीबी में) सच हो जाता है।दूसरे उदाहरणों को देखते हैं (मैं के रूप में 5 का उपयोग कर):

(5 और 2)

101 
010 
---- 
000 

(झूठी)

(5 और 4)

101 
100 
--- 
100 

(सच)

(5 और 8)

0101 
1000 
---- 
0000 

(गलत)

(5 और 16)

00101 
10000 
----- 
00000 

(गलत)

संपादित करें: और स्पष्ट रूप से मैं सवाल के पूरे बिंदु याद आती है - यहाँ सी # करने के लिए अनुवाद है:

cbi[1].Checked = i & 1 == 1; 
cbi[2].Checked = i & 2 == 2; 
cbi[3].Checked = i & 4 == 4; 
cbi[4].Checked = i & 8 == 8; 
cbi[5].Checked = i & 16 == 16; 

Answer 8

बस जोड़ने के लिए: यह 01 bitmasking कहा जाता है

एक बूलियन केवल 1 बिट की आवश्यकता है। कार्यान्वयन में अधिकांश प्रोग्रामिंग भाषा, एक बूलियन एक से अधिक बिट लेता है। पीसी में यह एक बड़ा अपशिष्ट नहीं होगा, लेकिन एम्बेडेड सिस्टम में आमतौर पर बहुत सीमित स्मृति स्थान होता है, इसलिए अपशिष्ट वास्तव में महत्वपूर्ण है। अंतरिक्ष को बचाने के लिए, बुलियन एक साथ पैक किए जाते हैं, इस तरह एक बूलियन चर केवल 1 बिट लेता है।

आप एक सरणी अनुक्रमण आपरेशन की तरह कुछ कर रही है, एक बाइट (= 8 बिट) 8 बूलियन चर की एक सरणी की तरह बनने के साथ के रूप में यह के बारे में सोच सकते हैं, तो हो सकता है कि आपका जवाब है: बूलियन्स की एक सरणी का उपयोग करें।

Answer 9

सी # में 0 बिटका उपयोग सीधे व्यक्तिगत बिट्स को इंडेक्स करने के लिए करें।

एक व्यक्ति बिट सेट करने के लिए मैं सीधा है:

b |= 1 << i; 

एक व्यक्ति बिट रीसेट करने के लिए मैं थोड़ा और अजीब है:

b &= ~(1 << i); 

ध्यान रखें कि दोनों बिटवाइज़ ऑपरेटर्स और शिफ्ट ऑपरेटर int पर सबकुछ प्रचारित करते हैं जो अप्रत्याशित रूप से कास्टिंग की आवश्यकता हो सकती है।

Answer 10

मैं थोड़ा twiddling (उदाहरण के लिए 0x10 के बजाय) हेक्साडेसिमल नोटेशन का उपयोग करना पसंद करते हैं। यह अधिक समझ में आता है क्योंकि आप अपनी बिट गहराई को 0x20000 के रूप में 131072 से बेहतर करते हैं।