Praktikal na aplikasyon (Bit mask, …)

"Hi, Amigo!"

"Gusto ko ring pag-usapan ang tungkol sa mga bitmask at XOR."

"Alam mo na na ang mga numero ay binubuo ng mga bit at maaari kang magsagawa ng iba't ibang mga operasyon sa mga bit na ito. Ang bitmask ay isang representasyon ng ilang magkakaibang mga lohikal na halaga (true/false value) bilang isang solong integer. Sa kasong ito, ang bawat boolean-value ay tumutugma sa isang partikular na bit. Narito kung paano ito magagawa:"

"Ang binary na representasyon ng mga kapangyarihan ng dalawa (1, 2, 4, 8, 16, 32, ...) ay nagsasangkot lamang ng pagtatakda ng isang bit:"

"Kaya, ang anumang integer ay maaaring ituring bilang isang array ng mga bit o isang array ng boolean value."

"Narito kung paano ka makakapag-imbak ng iba't ibang mga halaga ng boolean sa isang numero:"

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

"Ngayon ang bawat bit ay 1 kung totoo ang katumbas na boolean variable."

Sa aming kaso, ang mga variable a at c ay totoo, kaya ang resulta ay katumbas ng 1+4 == 5

0000 0101
0000 dcba

"Parang alam ko na ang nangyayari."

"Well, kung naiintindihan mo, let's move on."

"Ang isang int ay may 32 bits. Ang isa sa mga ito ay ginagamit para sa pag-sign ng numero, at ang isa pang 31 ay maaaring gamitin upang mag-imbak ng mga halaga ng 31 boolean variable."

"Ang isang long ay may 64 bits kung saan maaari kaming mag-imbak ng 63 boolean variable."

"Oo."

"Dozens of variables crammed in one number. Medyo marami iyon."

"Ngunit saan ito inilalapat?"

"Higit sa lahat sa mga sitwasyon kung saan kailangan mong mag-imbak ng maraming impormasyon tungkol sa mga bagay. Kapag nag-imbak ka ng maraming impormasyon tungkol sa isang bagay, palaging may ilang dosenang boolean variable. "Sa diskarteng ito, lahat sila ay maginhawang nakaimbak sa isang numero ."

"With emphasis on the word 'stored'. Kasi actually using the number isn't so convenient."

"Nga pala, iyon lang ang gusto kong itanong. Paano natin i-extract ang boolean value mula sa numero?"

"Ito ay hindi kumplikado sa lahat. Sabihin nating kailangan mong matukoy kung ang bit 6 ay nakatakda sa 1 (2 sa kapangyarihan ng lima ay 32). Maaari naming suriin tulad nito:"

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

"Kaya, ang pagtatrabaho sa mga bitmask ay may kasamang tatlong operasyon:"

1)  Magtakda ng isang partikular na bit sa 0

2)  Magtakda ng isang tiyak na bit sa 1

3)  Suriin ang halaga ng partikular na bit.

"Kunin ang bit 6, halimbawa."

"Paano mo itatakda ang bit 6 hanggang 1?"

result = result | 01000000;
result |= 01000000;

result = result & 10111111;
result &= 10111111;

c = result & 01000000;

"Iyan ay lubhang hindi pangkaraniwan, ngunit hindi mahirap. Man, ngayon ako ay isang hot-shot programmer."

"At isa pang maliit na tip sa kung paano madaling makakuha ng mga numero na may partikular na bit na nakatakda sa 0 o 1: 01000000 o 10111111."

Para dito, mayroon kaming mga  >> at  << operator.

"Ang 1 ay 2 sa zeroth power. Sa madaling salita, isang numero na may bit 0 na nakatakda sa 1. Kailangan namin ng isang numero na may bit 6 na set."

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

"Astig! Nakakatulong talaga yan sa mga ganyang kaso."

"Ngunit paano kung kailangan ko ng numero kung saan ang bawat bit ay nakatakda sa 1 maliban sa isang partikular na bit ay nakatakda sa 0?"

"Hindi rin mahirap iyan:"

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

"Sa madaling salita, ang lahat ng ito ay napaka-simple:"

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

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

c = result & (1 << 6);

"Mukhang hindi masyadong mahirap. Pero hindi ko agad maalala."

"Ngunit, kung makatagpo ka ng nakakatakot na expression tulad ng "result &= ~(1 << 6)" sa code ng ibang tao, malalaman mo na ang taong ito ay gumagawa lang ng bitmask."

"At kung madalas mo itong makatagpo, maaalala nito ang sarili nito para sa iyo."

"Remember itself... That sounds good. Thank's for the lesson."