Praktische toepassing (Bitmaskers, …)

"Hallo Amigo!"

"Ik wil het ook hebben over bitmasks en XOR."

"Je weet al dat getallen uit bits bestaan ​​en je kunt verschillende bewerkingen op deze bits uitvoeren. Een bitmasker is een weergave van verschillende logische waarden (true/false-waarden) als een enkel geheel getal. In dit geval komt elke booleaanse waarde overeen met een specifiek stukje. Hier is hoe dit kan worden gedaan:"

"De binaire weergave van machten van twee (1, 2, 4, 8, 16, 32, ...) omvat slechts het instellen van één bit:"

"Dus elk geheel getal kan worden behandeld als een reeks bits of een reeks booleaanse waarden."

"Hier ziet u hoe u verschillende booleaanse waarden in één getal kunt opslaan:"

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

"Nu is elk bit 1 als de corresponderende booleaanse variabele waar was."

In ons geval waren de variabelen a en c waar, dus resultaat is gelijk aan 1+4 == 5

0000 0101
0000 dcba

"Ik denk dat ik weet wat er aan de hand is."

"Nou, als je het begrijpt, laten we verder gaan."

"Een int heeft 32 bits. Een daarvan wordt gebruikt voor het getalteken en de andere 31 kunnen worden gebruikt om de waarden van 31 booleaanse variabelen op te slaan."

"Een long heeft 64 bits waarin we 63 booleaanse variabelen kunnen opslaan."

"Ja."

"Tientallen variabelen gepropt in één getal. Dat zijn er nogal wat."

"Maar waar wordt dit toegepast?"

"Voornamelijk in situaties waarin je veel informatie over objecten moet opslaan. Als je veel informatie over een object opslaat, zijn er altijd een paar dozijn booleaanse variabelen. "Met deze aanpak worden ze allemaal handig opgeslagen in één nummer ."

"Met de nadruk op het woord 'opgeslagen'. Want het nummer gebruiken is niet zo handig."

"Trouwens, dat is precies wat ik wilde vragen. Hoe halen we de booleaanse waarde uit het getal?"

"Het is helemaal niet ingewikkeld. Laten we zeggen dat je moet bepalen of bit 6 is ingesteld op 1 (2 tot de vijfde macht is 32). We zouden het als volgt kunnen controleren:"

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

"Het werken met bitmaskers omvat dus drie bewerkingen:"

1)  Zet ​​een specifiek bit op 0

2)  Zet ​​een specifiek bit op 1

3)  Controleer de waarde van het specifieke bit.

"Neem bijvoorbeeld bit 6."

"Hoe zet je bit 6 op 1?"

result = result | 01000000;
result |= 01000000;

result = result & 10111111;
result &= 10111111;

c = result & 01000000;

"Dat is hoogst ongebruikelijk, maar niet moeilijk. Man, nu ben ik een doorgewinterde programmeur."

"En nog een kleine tip over hoe je gemakkelijk getallen kunt krijgen met een specifieke bit ingesteld op 0 of 1: 01000000 of 10111111."

Hiervoor hebben we de  operatoren >> en  << .

"1 is 2 tot de nulde macht. Met andere woorden, een getal met bit 0 ingesteld op 1. We hebben een getal nodig met bit 6 ingesteld."

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

"Cool! Dat is erg handig in zulke gevallen."

"Maar wat als ik een getal nodig heb waarbij elk bit op 1 is ingesteld, behalve dat één specifiek bit op 0 is ingesteld?"

"Dat is ook niet moeilijk:"

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

"Met andere woorden, het is allemaal heel simpel:"

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

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

c = result & (1 << 6);

'Het ziet er niet heel moeilijk uit. Maar ik zal het me niet meteen herinneren.'

"Maar als je een enge uitdrukking tegenkomt zoals "resultaat &= ~(1 << 6)" in de code van iemand anders, dan weet je dat deze persoon gewoon met een bitmasker werkt."

"En als je het vaak tegenkomt, dan onthoudt het zichzelf voor je."

"Herinner jezelf... Dat klinkt goed. Bedankt voor de les."