Was ist Bitmaskierung?

Ich bin ziemlich neu in der C-Programmierung und bin auf Bitmaskierung gestoßen. Was ist das allgemeine Konzept und die Funktion der Bitmaskierung?

Beispiele werden sehr geschätzt.

Eine Maske definiert, welche Bits Sie behalten möchten und welche Bits Sie löschen möchten.

Maskieren ist das Anwenden einer Maske auf einen Wert. Dies wird erreicht, indem Sie Folgendes tun:

• Bitweises ANDing, um eine Teilmenge der Bits im Wert zu extrahieren
• Bitweises ORing, um eine Teilmenge der Bits im Wert zu setzen
• Bitweises XORing, um eine Teilmenge der Bits im Wert umzuschalten

Unten ist ein Beispiel für das Extrahieren einer Teilmenge der Bits im Wert:

Mask:   00001111b
Value:  01010101b

Das Anwenden der Maske auf den Wert bedeutet, dass wir die ersten (höheren) 4 Bits löschen und die letzten (niedrigeren) 4 Bits behalten möchten. Somit haben wir die unteren 4 Bits extrahiert. Das Ergebnis ist:

Mask:   00001111b
Value:  01010101b
Result: 00000101b

Die Maskierung wird mit AND implementiert, also erhalten wir in C:

uint8_t stuff(...) {
  uint8_t mask = 0x0f;   // 00001111b
  uint8_t value = 0x55;  // 01010101b
  return mask & value;
}

Hier ist ein ziemlich häufiger Anwendungsfall: Einzelne Bytes aus einem größeren Wort extrahieren. Wir definieren die höherwertigen Bits im Wort als erstes Byte. Wir verwenden dafür zwei Operatoren, &und >> (nach rechts verschieben). So können wir die vier Bytes aus einer 32-Bit-Ganzzahl extrahieren:

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
    ...
}

Beachten Sie, dass Sie die Reihenfolge der obigen Operatoren ändern könnten, Sie könnten zuerst die Maske und dann die Verschiebung ausführen. Die Ergebnisse sind die gleichen, aber jetzt müssten Sie eine andere Maske verwenden:

uint32_t byte3 = (value & 0xff00) >> 8;

Maskieren bedeutet, einen gewünschten Teil der Informationen zu behalten, zu ändern oder zu entfernen. Sehen wir uns eine Bildmaskierungsoperation an. wie diese Maskierungsoperation alles entfernt, was keine Haut ist:

Wir machen eine UND Betrieb in diesem Beispiel. Es gibt auch andere Maskierungsoperatoren—ODER und XOR.

Bitmaskierung bedeutet, Bits eine Maske aufzuerlegen. Hier ist eine Bitmaskierung mit UND—

     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

Also nur die mittleren vier Bits (so wie diese Bits sind 1 in dieser Maske) verbleiben.

Sehen wir uns das mal an 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

Jetzt werden die mittleren vier Bits umgedreht (1 wurde 0, 0 wurde 1).

Über eine Bitmaske können wir also auf einzelne Bits zugreifen (Beispiele). Manchmal kann diese Technik auch zur Leistungssteigerung eingesetzt werden. Nehmen Sie dies zum Beispiel-

bool isOdd(int i) {
    return i%2;
}

Diese Funktion gibt an, ob eine ganze Zahl ungerade/gerade ist. Wir können das gleiche Ergebnis effizienter mit einer Bitmaske erzielen –

bool isOdd(int i) {
    return i&1;
}

Kurze Erklärung: Wenn die niedrigstwertige Bit einer Binärzahl ist 1 dann ist es seltsam; zum 0 es wird gleichmäßig sein. Also, indem Sie es tun UND mit 1 Wir entfernen alle anderen Bits mit Ausnahme des niederwertigsten Bits, dh:

     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