व्यावहारिक अनुप्रयोग (बिट मास्क, …)

"हाय, अमिगो!"

"मला बिटमास्क आणि XOR बद्दल देखील बोलायचे आहे."

"तुम्हाला आधीच माहित आहे की संख्यांमध्ये बिट्स असतात आणि तुम्ही या बिट्सवर विविध ऑपरेशन्स करू शकता. बिटमास्क हे एकल पूर्णांक म्हणून अनेक भिन्न तार्किक मूल्यांचे (सत्य/असत्य मूल्यांचे) प्रतिनिधित्व आहे. या प्रकरणात, प्रत्येक बुलियन-मूल्याशी संबंधित आहे विशिष्ट बिट. हे कसे केले जाऊ शकते ते येथे आहे:"

"दोन (1, 2, 4, 8, 16, 32, ...) शक्तींच्या बायनरी प्रतिनिधित्वामध्ये फक्त एक बिट सेट करणे समाविष्ट आहे:"

"म्हणून, कोणत्याही पूर्णांकाला बिट्सचा अॅरे किंवा बुलियन व्हॅल्यूजचा अॅरे मानला जाऊ शकतो."

"तुम्ही वेगवेगळ्या बुलियन व्हॅल्यूज एका नंबरमध्ये कसे संग्रहित करू शकता ते येथे आहे:"

boolean a = true;
boolean b = false;
boolean c = true;
boolean d = false;

int result = 0;
 if (a) result += 1; // 1 == 20 — bit 0
 if (b) result += 2; // 2 == 21 — bit 1
 if (c) result += 4; // 4 == 22 — bit 2
 if (d) result += 8; // 8 == 23 — bit 3

"जर संबंधित बुलियन व्हेरिएबल सत्य असेल तर आता प्रत्येक बिट 1 आहे."

आमच्या बाबतीत, a आणि c व्हेरिएबल्स सत्य होते, त्यामुळे परिणाम 1+4 == 5 च्या बरोबरीचा आहे.

0000 0101
0000 dcba

"मला वाटतं मला माहित आहे काय होत आहे."

"बरं, समजलं तर पुढे जाऊया."

"इंटमध्ये 32 बिट्स असतात. त्यापैकी एक नंबरच्या चिन्हासाठी वापरला जातो आणि इतर 31 चा वापर 31 बुलियन व्हेरिएबल्सची मूल्ये साठवण्यासाठी केला जाऊ शकतो."

"ए लाँगमध्ये 64 बिट असतात जिथे आपण 63 बुलियन व्हेरिएबल्स साठवू शकतो."

"हो."

"एकाच संख्येत डझनभर व्हेरिएबल्स तयार झाले आहेत. ते अगदी काही आहेत."

"पण हे कुठे लागू आहे?"

"मुख्यत: अशा परिस्थितीत जिथे तुम्हाला वस्तूंबद्दल बरीच माहिती साठवायची असते. जेव्हा तुम्ही एखाद्या वस्तूबद्दल भरपूर माहिती साठवता तेव्हा तिथे नेहमी दोन डझन बुलियन व्हेरिएबल्स असतात. ."

"संचयित' शब्दावर जोर देऊन. कारण प्रत्यक्षात संख्या वापरणे इतके सोयीचे नाही."

"बाय द वे, मला तेच विचारायचे होते. नंबरमधून बुलियन व्हॅल्यू कशी काढायची?"

"हे अजिबात क्लिष्ट नाही. बिट 6 हे 1 वर सेट केले आहे की नाही हे आपण निर्धारित करणे आवश्यक आहे असे म्हणू या (2 ते पाचची पॉवर 32 आहे). आम्ही असे तपासू शकतो:"

int a = 32; // 25 == 0010 0000
int b = 8; // 23 == 0000 1000
int c = 2; // 21 == 0000 0010

int result = a + b + c; // 32 + 8 + 2 == 42 == 0010 1010

int a = result & 32; // 0010 1010 & 0010 0000 = 0010 0000
int b = result & 8; // 0010 1010 & 0000 1000 = 0000 1000
int c = result & 2; // 0010 1010 & 0000 0010 = 0000 0010

"अशा प्रकारे, बिटमास्कसह कार्य करण्यासाठी तीन ऑपरेशन्स समाविष्ट आहेत:"

1)  विशिष्ट बिट 0 वर सेट करा

2)  विशिष्ट बिट 1 वर सेट करा

3)  विशिष्ट बिटचे मूल्य तपासा.

"उदाहरणार्थ, बिट 6 घ्या."

"तुम्ही बिट 6 ते 1 कसे सेट कराल?"

result = result | 01000000;
result |= 01000000;

result = result & 10111111;
result &= 10111111;

c = result & 01000000;

"हे अत्यंत असामान्य आहे, पण अवघड नाही. यार, आता मी हॉट-शॉट प्रोग्रामर आहे."

"आणि 0 किंवा 1: 01000000 किंवा 10111111 वर सेट केलेल्या विशिष्ट बिटसह क्रमांक सहजपणे कसे मिळवायचे याबद्दल आणखी एक छोटी टीप."

यासाठी, आमच्याकडे  >> आणि  << ऑपरेटर आहेत.

"1 हे शून्य पॉवरचे 2 आहे. दुसऱ्या शब्दांत, बिट 0 असलेली संख्या 1 वर सेट केली आहे. आम्हाला बिट 6 सेट असलेली संख्या आवश्यक आहे."

int c = 1 << 6; // 0000 0001 << 6 == 0100 0000 == 64

"छान! अशा केसेससाठी ते खरोखर उपयुक्त आहे."

"पण जर मला अशी संख्या हवी असेल जिथे प्रत्येक बिट 1 वर सेट केला असेल तर एक विशिष्ट बिट 0 वर सेट केला असेल?"

"हे देखील अवघड नाही:"

int d = ~(1 << 6); // ~0100 0000 == 10111111

"दुसर्‍या शब्दात, हे सर्व अगदी सोपे आहे:"

result = result | (1 << 6);
result |= (1 << 6);

result = result & ~(1 << 6);
result &= ~(1 << 6);

c = result & (1 << 6);

"हे फार अवघड वाटत नाही. पण मला लगेच आठवणार नाही."

"परंतु, जर तुम्हाला एखाद्या दुसर्‍याच्या कोडमध्ये "परिणाम &= ~(1 << 6)" सारखी भीतीदायक अभिव्यक्ती आढळली, तर तुम्हाला कळेल की ही व्यक्ती फक्त बिटमास्कसह काम करत आहे."

"आणि जर तुम्हाला ते वारंवार भेटले तर ते तुमच्यासाठी स्वतःला लक्षात ठेवेल."

"स्वतःला लक्षात ठेवा... छान वाटतंय. धड्यासाठी धन्यवाद."