Praktisk bruk (bitmasker, ...)

"Hei, Amigo!"

"Jeg vil også snakke om bitmasker og XOR."

"Du vet allerede at tall består av biter, og du kan utføre forskjellige operasjoner på disse bitene. En bitmaske er en representasjon av flere forskjellige logiske verdier (sanne/falske verdier) som et enkelt heltall. I dette tilfellet tilsvarer hver boolske verdi til en spesifikk bit. Slik kan dette gjøres:"

"Den binære representasjonen av potenser av to (1, 2, 4, 8, 16, 32, ...) innebærer bare å sette en bit:"

"Så, ethvert heltall kan behandles som en rekke biter eller en rekke boolske verdier."

"Slik kan du lagre forskjellige boolske verdier i ett tall:"

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

"Nå er hver bit 1 hvis den tilsvarende boolske variabelen var sann."

I vårt tilfelle var variablene a og c sanne, så resultatet er lik 1+4 == 5

0000 0101
0000 dcba

— Jeg tror jeg vet hva som skjer.

"Vel, hvis du forstår, la oss gå videre."

"En int har 32 biter. En av dem brukes for tallets tegn, og den andre 31 kan brukes til å lagre verdiene til 31 boolske variabler."

"En lang har 64 biter der vi kan lagre 63 boolske variabler."

"Japp."

"Dusinvis av variabler stappet i ett tall. Det er ganske mange."

"Men hvor brukes dette?"

"Hovedsakelig i situasjoner der du trenger å lagre mye informasjon om objekter. Når du lagrer mye informasjon om et objekt, er det alltid et par dusin boolske variabler. "Med denne tilnærmingen er de alle praktisk lagret i ett nummer ."

"Med vekt på ordet "lagret". Fordi det faktisk ikke er så praktisk å bruke nummeret."

"Forresten, det var akkurat det jeg ville spørre. Hvordan trekker vi ut den boolske verdien fra tallet?"

"Det er ikke komplisert i det hele tatt. La oss si at du må finne ut om bit 6 er satt til 1 (2 i potensen av fem er 32). Vi kan sjekke slik:"

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

"Derfor involverer arbeid med bitmasker tre operasjoner:"

1)  Sett en bestemt bit til 0

2)  Sett en bestemt bit til 1

3)  Sjekk verdien til den spesifikke biten.

"Ta bit 6, for eksempel."

"Hvordan setter du bit 6 til 1?"

result = result | 01000000;
result |= 01000000;

result = result & 10111111;
result &= 10111111;

c = result & 01000000;

"Det er høyst uvanlig, men ikke vanskelig. Mann, nå er jeg en hot-shot programmerer."

"Og ett lite tips til om hvordan du enkelt kan få tall med en bestemt bit satt til 0 eller 1: 01000000 eller 10111111."

For dette har vi  operatorene >> og  << .

"1 er 2 til null potens. Med andre ord, et tall med bit 0 satt til 1. Vi trenger et tall med bit 6 satt."

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

"Kult! Det er veldig nyttig for slike saker."

"Men hva om jeg trenger et tall der hver bit er satt til 1 bortsett fra en bestemt bit er satt til 0?"

"Det er heller ikke vanskelig:"

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

"Med andre ord, det hele er veldig enkelt:"

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

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

c = result & (1 << 6);

"Det ser ikke veldig vanskelig ut. Men jeg kommer ikke til å huske det med en gang."

"Men hvis du møter et skummelt uttrykk som "resultat &= ~(1 << 6)" i andres kode, vil du vite at denne personen bare jobber med en bitmaske."

"Og hvis du møter det ofte, vil det huske seg selv for deg."

"Husk seg selv... Det høres bra ut. Takk for leksjonen."