Je suis assez nouveau dans la 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.
Je suis assez nouveau dans la 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.
Réponses:
Un masque définit les bits que vous souhaitez conserver et les bits que vous souhaitez effacer.
Le masquage est l'acte d'appliquer un masque à une valeur. Ceci est accompli en faisant:
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 (supérieurs) et conserver les 4 derniers bits (inférieurs). Ainsi, nous avons 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 nous obtenons:
uint8_t stuff(...) {
uint8_t mask = 0x0f; // 00001111b
uint8_t value = 0x55; // 01010101b
return mask & value;
}
Voici un cas d'utilisation assez courant: l'extraction d'octets individuels d'un mot plus grand. Nous définissons les bits de poids fort dans le mot comme le premier octet. Nous utilisons deux opérateurs pour cela &
, et >>
(décalage vers la droite). Voici comment nous pouvons 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 maintenant, vous devrez utiliser un masque différent:
uint32_t byte3 = (value & 0xff00) >> 8;
&
.
#define MASK 0x000000FF .... my_uint32_t &= ~MASK
.
Masquer signifie conserver / modifier / supprimer une partie souhaitée de l'information. Permet de voir une opération de masquage d'image; comme- cette opération de masquage supprime tout ce qui n'est pas de la peau-
Nous faisons l' opération AND dans cet exemple. Il existe également d'autres opérateurs de masquage - OR , XOR .
Bit-Masking signifie imposer un masque sur les bits. Voici un peu de masquage avec 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]
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
devenus 0
, sont 0
devenus 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 pair / impair. Nous pouvons obtenir le même résultat avec plus d'efficacité en utilisant le masque de bits-
bool isOdd(int i) {
return i&1;
}
Explication courte : Si le bit le moins significatif d'un nombre binaire est 1
alors il est impair; car 0
ce sera égal. Donc, en faisant ET avec, 1
nous supprimons tous les autres bits à l'exception du bit le moins significatif, c'est-à-dire:
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]