बिट मास्किंग क्या है?

191

मैं सी प्रोग्रामिंग के लिए काफी नया हूं, और मुझे थोडा मास्किंग करना पड़ा। क्या कोई मुझे सामान्य अवधारणा और बिट मास्किंग के कार्य के बारे में समझा सकता है? उदाहरणों की बहुत प्रशंसा की जाती है।

— Mr.Z
स्रोत

क्या आप बिटकॉइन ऑपरेटर्स जैसे कि & | ^ और सामान्य रूप से बूलियन तर्क? मुखौटा संचालन के किसी भी स्पष्टीकरण के लिए इसकी आवश्यकता होगी।

— पॉल आर

हां मुझे बिटवाइज़ ऑपरेटरों और बूलियन लॉजिक की समझ है

— Mr.Z

मुझे पता है कि लिंक पोस्ट नहीं किए जाने चाहिए, लेकिन विकिपीडिया स्पष्टीकरण बहुत अच्छा है: en.wikipedia.org/wiki/Mask_(computing)

— pevik

@pevik लिंक को पोस्ट करने के लिए ठीक है, लेकिन कुछ विवरण के साथ ताकि अगर किसी दिन लिंक मर जाए, तो पोस्ट अभी भी जवाब देने के अपने उद्देश्य की पूर्ति करने में सक्षम है। यह भी लिंक मात्र प्रचार के लिए नहीं होना चाहिए।

— डेक्सटर

जवाबों:

244

एक मुखौटा परिभाषित करता है कि आप किन बिट्स को रखना चाहते हैं, और किन बिट्स को आप साफ़ करना चाहते हैं।

मास्किंग एक मूल्य पर मास्क लगाने का कार्य है। ऐसा करने से पूरा होता है:

बिटवाइज एंडिंग मूल्य में बिट्स का सबसेट निकालने के लिए
बिटवाइज़ ओरिंग मूल्य में बिट्स का सबसेट सेट करने के लिए
मूल्य में बिट्स के सबसेट को टॉगल करने के लिए बिटवाइज़ XORing

नीचे मूल्य में बिट्स का सबसेट निकालने का एक उदाहरण है:

Mask:   00001111b
Value:  01010101b

मास्क को मूल्य पर लागू करने का मतलब है कि हम पहले (उच्च) 4 बिट्स को खाली करना चाहते हैं, और अंतिम (निचले) 4 बिट्स को रखना चाहते हैं। इस प्रकार हमने निचले 4 बिट्स निकाले हैं। परिणाम है:

Mask:   00001111b
Value:  01010101b
Result: 00000101b

मास्किंग AND का उपयोग करके कार्यान्वित किया जाता है, इसलिए C में हम प्राप्त करते हैं:

uint8_t stuff(...) {
  uint8_t mask = 0x0f;   // 00001111b
  uint8_t value = 0x55;  // 01010101b
  return mask & value;
}

यहाँ एक काफी सामान्य उपयोग-मामला है: एक बड़े शब्द से अलग-अलग बाइट्स निकालना। हम पहले बाइट के रूप में शब्द में उच्च-क्रम बिट्स को परिभाषित करते हैं। हम इसके लिए दो ऑपरेटरों का उपयोग करते हैं &, और >>(दाएं शिफ्ट)। यह है कि हम 32-बिट पूर्णांक से चार बाइट्स कैसे निकाल सकते हैं:

void more_stuff(uint32_t value) {             // Example value: 0x01020304
    uint32_t byte1 = (value >> 24);           // 0x01020304 >> 24 is 0x01 so
                                              // no masking is necessary
    uint32_t byte2 = (value >> 16) & 0xff;    // 0x01020304 >> 16 is 0x0102 so
                                              // we must mask to get 0x02
    uint32_t byte3 = (value >> 8)  & 0xff;    // 0x01020304 >> 8 is 0x010203 so
                                              // we must mask to get 0x03
    uint32_t byte4 = value & 0xff;            // here we only mask, no shifting
                                              // is necessary
    ...
}

ध्यान दें कि आप ऊपर के ऑपरेटरों के आदेश को बदल सकते हैं, आप पहले मुखौटा, फिर बदलाव कर सकते हैं। परिणाम समान हैं, लेकिन अब आपको एक अलग मास्क का उपयोग करना होगा:

uint32_t byte3 = (value & 0xff00) >> 8;

— user239558
स्रोत

अच्छा उत्तर लेकिन मास्किंग को OR या XOR ऑपरेशंस और एक उपयुक्त मास्क के साथ विशिष्ट बिट्स की स्थापना या टॉगल करने के लिए भी लागू किया जा सकता है ।

— पॉल आर

@ user239558 उदाहरण और उचित वाक्यविन्यास के लिए धन्यवाद। @ पॉल आर। क्या मैं केवल उपयोगकर्ता 239558 द्वारा प्रदान किए गए उदाहरण में मुखौटा और मान कहूँगा

— Mr.Z

@ Mr.Z: C, C ++ और संबंधित भाषाओं में आप बिटवाइड और ऑपरेटर चाहेंगे , जो इस प्रकार लिखा जाता है &।

— पॉल आर

@ Mr.Z उदाहरण के लिए: एक uint32_t का एक बाइट साफ़ करें जिससे सामग्री दूर हो #define MASK 0x000000FF .... my_uint32_t &= ~MASK।

— लुंडिन

bइंगित करने के लिए बाइनरी शाब्दिक सभी संकलक द्वारा समर्थित नहीं है, सही है?

— अघेयूर

मास्किंग का अर्थ है सूचना के वांछित भाग को रखना / बदलना / हटाना। आइए एक छवि-मास्किंग ऑपरेशन देखें; जैसे- यह मास्किंग ऑपरेशन किसी भी चीज को हटा रहा है जो त्वचा नहीं है-

हम इस उदाहरण में AND ऑपरेशन कर रहे हैं । अन्य मास्किंग ऑपरेटर भी हैं- OR , XOR ।

बिट-मास्किंग का मतलब बिट्स पर मास्क लगाना है। यहाँ थोड़ा सा मास्किंग है - और

     1 1 1 0 1 1 0 1   [input]
(&)  0 0 1 1 1 1 0 0    [mask]
------------------------------
     0 0 1 0 1 1 0 0  [output]

तो, केवल मध्य 4 बिट्स (जैसा कि इन बिट्स 1इस मुखौटा में हैं) रहते हैं।

XOR के साथ इसे देखें -

     1 1 1 0 1 1 0 1   [input]
(^)  0 0 1 1 1 1 0 0    [mask]
------------------------------
     1 1 0 1 0 0 0 1  [output]

अब, मध्य 4 बिट्स फ़्लिप ( 1बन गए 0, 0बन गए 1) हैं।

इसलिए, बिट-मास्क का उपयोग करके हम व्यक्तिगत बिट्स [ उदाहरण ] तक पहुंच सकते हैं । कभी-कभी, इस तकनीक का उपयोग प्रदर्शन में सुधार के लिए भी किया जा सकता है। उदाहरण के लिए इसे लें-

bool isOdd(int i) {
    return i%2;
}

यह फ़ंक्शन बताता है कि क्या पूर्णांक विषम है / है। हम बिट-मास्क का उपयोग करके अधिक दक्षता के साथ एक ही परिणाम प्राप्त कर सकते हैं-

bool isOdd(int i) {
    return i&1;
}

संक्षिप्त व्याख्या : यदि बाइनरी संख्या का कम से कम महत्वपूर्ण बिट है 1तो यह विषम है; इसके लिए 0भी होगा। तो, ऐसा करके और साथ 1हम कम से कम महत्वपूर्ण बिट यानी के अलावा अन्य सभी बिट्स निकाल रहे हैं:

     55  ->  0 0 1 1 0 1 1 1   [input]
(&)   1  ->  0 0 0 0 0 0 0 1    [mask]
---------------------------------------
      1  <-  0 0 0 0 0 0 0 1  [output]

— मिन्हास कमल
स्रोत

इसके अलावा, एक पूर्णांक को विषम संख्या में बदलने के लिए। यदि यह एक सम संख्या है: i = i | 1 | इस काम में आता है जब हम 1 की तरह, 3, 5, ..., 2, 4, 6, ... एक दृश्य उत्पन्न करने के लिए कोशिश कर रहे हैं

— हर्षित शर्मा

आप पूर्णांक से केवल कम से कम महत्वपूर्ण बिट के साथ संख्या ज्ञात करने के लिए निम्नलिखित ऑपरेशन का उपयोग कर सकते हैं: lsb = i & -i

— हर्षित शर्मा