web-dev-qa-db-fra.com

Qu'est-ce que Bit Masking?

Je suis assez nouveau en programmation C et j’ai rencontré le masquage de bits. Quelqu'un peut-il m'expliquer le concept général et la fonction du masquage de bits? Les exemples sont très appréciés.

cbit-manipulationbitwise-operatorsterminologybitmask
148
Mr.Z

Un masque définit les bits que vous souhaitez conserver et ceux que vous souhaitez effacer.

Le masquage consiste à appliquer un masque à une valeur. Ceci est accompli en faisant:

  • ANDing au niveau du bit pour extraire un sous-ensemble des bits de la valeur
  • OU bit à bit pour définir un sous-ensemble de bits dans la valeur
  • XORing au niveau des bits afin de basculer un sous-ensemble des bits dans la valeur

Voici un exemple d'extraction d'un sous-ensemble de bits dans la valeur:

Mask:   00001111b
Value:  01010101b

Appliquer le masque à la valeur signifie que nous voulons effacer les 4 premiers bits (les plus élevés) et conserver les 4 derniers bits (les plus bas). Nous avons donc extrait les 4 bits inférieurs. Le résultat est:

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

Le masquage est implémenté en utilisant AND, donc en C on obtient:

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

Voici un cas d'utilisation assez courant: Extraire des octets individuels à partir d'un mot plus volumineux. Nous définissons les bits de poids fort dans le mot comme premier octet. Nous utilisons deux opérateurs pour cela, & et >> (décalage à droite). Voici comment extraire les quatre octets d'un entier 32 bits:

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

Notez que vous pouvez changer l'ordre des opérateurs ci-dessus, vous pouvez d'abord faire le masque, puis le décalage. Les résultats sont les mêmes, mais il faudrait maintenant utiliser un masque différent:

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

Masquer signifie conserver/modifier/supprimer une partie d'informations souhaitée. Permet de voir une opération de masquage d'image; comme- cette opération de masquage enlève tout ce qui n'est pas peau-

enter image description here

Nous faisons l'opération ET dans cet exemple. Il existe également d'autres opérateurs de masquage - OU, XOR.

Masquage des bits signifie imposer un masque sur des bits. Voici un masquage de bits avec ET -

     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]

Ainsi, seuls les 4 bits du milieu (car ces bits sont 1 dans ce masque) restent.

Voyons cela avec 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]

Maintenant, les 4 bits du milieu sont retournés (1 est devenu 0, 0 est devenu 1).

Ainsi, en utilisant le masque de bits, nous pouvons accéder à des bits individuels [ exemples ]. Parfois, cette technique peut également être utilisée pour améliorer les performances. Prenez ceci par exemple-

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

Cette fonction indique si un entier est impair/pair. Nous pouvons obtenir le même résultat avec plus d'efficacité en utilisant bit-mask-

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

Explication courte : Si le bit le moins significatif d'un nombre binaire est 1, il est impair; pour 0 ce sera pair. Donc, en faisant ET avec 1, nous supprimons tous les autres bits sauf le bit le moins significatif, à savoir:

     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]
29
Minhas Kamal