Wat is bitmaskering?

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 1zijn 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 (1werd 0, 0werd 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 1is, dan is het oneven; voor 0zal het even zijn. Dus door ANDmet 1te 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]