Gyakorlati alkalmazás (bitmaszkok,…)

– Szia Amigo!

– A bitmaszkokról és az XOR-ról is szeretnék beszélni.

"Már tudja, hogy a számok bitekből állnak, és ezekkel a bitekkel különféle műveleteket hajthat végre. A bitmaszk több különböző logikai érték (igaz/hamis érték) egyetlen egész számként történő megjelenítése. Ebben az esetben minden logikai érték megfelel a egy konkrét darab. Ezt a következőképpen teheti meg:"

"A kettő hatványainak bináris ábrázolása (1, 2, 4, 8, 16, 32, ...) csak egy bit beállítását foglalja magában:"

"Tehát minden egész szám kezelhető bitek tömbjeként vagy logikai értékek tömbjeként."

"Íme, hogyan tárolhat különböző logikai értékeket egy számban:"

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

"Most minden bit 1, ha a megfelelő logikai változó igaz."

Esetünkben az a és c változók igazak voltak, így az eredmény 1+4 == 5

0000 0101
0000 dcba

– Azt hiszem, tudom, mi történik.

– Nos, ha megérted, menjünk tovább.

"Egy intnek 32 bitje van. Az egyik a szám előjelére szolgál, a másik 31 pedig 31 logikai változó értékének tárolására szolgál."

"A longnak 64 bitje van, ahol 63 logikai változót tárolhatunk."

"Igen."

"Több tucat változót zsúfoltak egy számba. Ez elég sok."

– De hol alkalmazzák ezt?

"Főleg olyan helyzetekben, amikor sok információt kell tárolnia az objektumokról. Ha sok információt tárol egy objektumról, mindig van néhány tucat logikai változó. "Ezzel a megközelítéssel mindegyik kényelmesen egy számban tárolható ."

"A "tárolt" szóra helyezve a hangsúlyt. Mert valójában a szám használata nem olyan kényelmes."

"Mellesleg, pont ezt akartam kérdezni. Hogyan vonjuk ki a logikai értéket a számból?"

"Egyáltalán nem bonyolult. Tegyük fel, hogy meg kell határoznia, hogy a 6-os bit 1-re van-e állítva (2, öt hatványa 32). Ezt így ellenőrizhetjük:"

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

"Így a bitmaszkokkal való munka három műveletből áll:"

1)  Állítson egy adott bitet 0-ra

2)  Állítson egy adott bitet 1-re

3)  Ellenőrizze az adott bit értékét.

"Vegyük például a 6. bitet."

"Hogyan állítod be a 6-os bitet 1-re?"

result = result | 01000000;
result |= 01000000;

result = result & 10111111;
result &= 10111111;

c = result & 01000000;

"Ez nagyon szokatlan, de nem nehéz. Ember, most egy gyors programozó vagyok."

"És még egy kis tipp, hogyan lehet egyszerűen számokat kapni, ha egy adott bit 0-ra vagy 1-re van állítva: 01000000 vagy 10111111."

Ehhez a  >> és  << operátorok állnak rendelkezésünkre.

"1 2 a nulladik hatványhoz. Más szavakkal, egy szám, amelynek 0 bitje 1-re van állítva. Szükségünk van egy számra, amelynek 6 bitje van beállítva."

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

"Csodálatos! Ez nagyon hasznos az ilyen esetekben."

"De mi van, ha olyan számra van szükségem, ahol minden bit 1-re van állítva, kivéve egy bizonyos bitet 0-ra?"

– Ez sem nehéz:

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

"Más szóval, minden nagyon egyszerű:"

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

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

c = result & (1 << 6);

– Nem tűnik túl nehéznek. De nem fogok azonnal emlékezni rá.

"De ha valaki más kódjában olyan ijesztő kifejezéssel találkozik, mint az "eredmény &= ~(1 << 6)", akkor tudni fogja, hogy ez a valaki csak bitmaszkot használ."

"És ha gyakran találkozol vele, akkor emlékezni fog rád."

"Emlékezz önmagára... Ez jól hangzik. Köszönöm a leckét."