Ik ben vrij nieuw in C-programmeren en ik kwam bitmaskering tegen. Kan iemand mij het algemene concept en de functie van bitmaskering uitleggen? Voorbeelden worden zeer op prijs gesteld.
Antwoord 1, autoriteit 100%
Een masker bepaalt welke bits u wilt behouden en welke bits u wilt wissen.
Masken is het toepassen van een masker op een waarde. Dit wordt bereikt door het volgende te doen:
- Bitwise ANDing om een subset van de bits in de waarde te extraheren
- Bitwise ORing om een subset van de bits in de waarde in te stellen
- Bitwise XORing om een subset van de bits in de waarde te wisselen
Hieronder is een voorbeeld van het extraheren van een subset van de bits in de waarde:
Mask: 00001111b
Value: 01010101b
Het masker toepassen op de waarde betekent dat we de eerste (hogere) 4 bits willen wissen en de laatste (lagere) 4 bits willen behouden. We hebben dus de onderste 4 bits geëxtraheerd. Het resultaat is:
Mask: 00001111b
Value: 01010101b
Result: 00000101b
Masking wordt geïmplementeerd met AND, dus in C krijgen we:
uint8_t stuff(...) {
uint8_t mask = 0x0f; // 00001111b
uint8_t value = 0x55; // 01010101b
return mask & value;
}
Hier is een vrij algemeen gebruik: individuele bytes extraheren uit een groter woord. We definiëren de bits van hoge orde in het woord als de eerste byte. We gebruiken hiervoor twee operators, &
, en >>
(schuif naar rechts). Zo kunnen we de vier bytes extraheren uit een 32-bits geheel getal:
void more_stuff(uint32_t value) { // Example value: 0x01020304
uint32_t byte1 = (value >> 24); // 0x01020304 >> 24 is 0x01 so
// no masking is necessary
uint32_t byte2 = (value >> 16) & 0xff; // 0x01020304 >> 16 is 0x0102 so
// we must mask to get 0x02
uint32_t byte3 = (value >> 8) & 0xff; // 0x01020304 >> 8 is 0x010203 so
// we must mask to get 0x03
uint32_t byte4 = value & 0xff; // here we only mask, no shifting
// is necessary
...
}
Merk op dat u de volgorde van de bovenstaande operators kunt wijzigen, u kunt eerst het masker doen en daarna de dienst. De resultaten zijn hetzelfde, maar nu zou je een ander masker moeten gebruiken:
uint32_t byte3 = (value & 0xff00) >> 8;
Antwoord 2, autoriteit 43%
Maskingbetekent het behouden/wijzigen/verwijderen van een gewenst deel van de informatie. Laten we een beeldmaskeringsoperatie bekijken; zoals- deze maskeringsoperatie verwijdert alles dat geen huid is-
In dit voorbeeld voeren we de bewerking ANDuit. Er zijn ook andere maskeringsoperators: OR, XOR.
Bit-Maskingbetekent het opleggen van een masker over bits. Hier is een bit-masking met AND–
1 1 1 0 1 1 0 1 [input] (&) 0 0 1 1 1 1 0 0 [mask] ------------------------------ 0 0 1 0 1 1 0 0 [output]
Dus, alleen de middelste 4 bits (aangezien deze bits 1
zijn in dit masker) blijven over.
Laat dit zien met XOR–
1 1 1 0 1 1 0 1 [input] (^) 0 0 1 1 1 1 0 0 [mask] ------------------------------ 1 1 0 1 0 0 0 1 [output]
Nu worden de middelste 4 bits omgedraaid (1
werd 0
, 0
werd 1
).
Dus met bit-mask hebben we toegang tot individuele bits [voorbeelden]. Soms kan deze techniek ook worden gebruikt om de prestaties te verbeteren. Neem dit bijvoorbeeld-
bool isOdd(int i) {
return i%2;
}
Deze functie vertelt of een geheel getal even/oneven is. We kunnen hetzelfde resultaat met meer efficiëntie bereiken met behulp van bit-mask-
bool isOdd(int i) {
return i&1;
}
Korte uitleg: als het minst significante deelvan een binair getal 1
is, dan is het oneven; voor 0
zal het even zijn. Dus door ANDmet 1
te doen, verwijderen we alle andere bits behalve het minst significante bit, d.w.z.:
55 -> 0 0 1 1 0 1 1 1 [input] (&) 1 -> 0 0 0 0 0 0 0 1 [mask] --------------------------------------- 1 <- 0 0 0 0 0 0 0 1 [output]