Masque et d'en extraire les bits en C

De masquage est fait en mettant tous les bits à l'exception de celle(s) que vous souhaitez 0. Donc, disons que vous avez un 8 bits variable et que vous voulez vérifier si la 5ème bits de l'est 1. Disons que votre variable est 00101100. Pour masquer tous les autres bits nous avons mis tous les bits à l'exception de la 5e à 0, en utilisant le & opérateur:

00101100 & 00010000

Maintenant ce que cela fait, c'est pour tous les bits sauf le 5e, le bit de l'octet sur le droit sera de 0, de sorte que le résultat de la & l'opération sera de 0. Pour la 5ème peu, cependant, la valeur à partir de la droite est 1, alors le résultat sera quelle que soit la valeur de la 5e bits à partir de la gauche de l'octet - dans ce cas, 0:

Maintenant de vérifier cette valeur, vous devez comparer avec quelque chose. Pour ce faire, il suffit de comparer le résultat avec l'octet de droite:

result = (00101100 & 00010000) == 00000000

De généraliser cela, vous pouvez récupérer tous les bits de l'octet de gauche, simplement en déplaçant 00000001 jusqu'à ce que vous obtenez la peu que vous le souhaitez. La fonction suivante réalise ceci:

int getBit(char byte, int bitNum)
{
    return (byte & (0x1 << (bitNum - 1)))
}

Cela fonctionne sur vars de n'importe quelle taille, qu'il est à 8, 16, 32 ou 64 (ou quoi que ce soit d'autre d'ailleurs).

OriginalL'auteur PandaConda

Tout d'abord, les chiffres binaires sont (généralement) compté à partir de la droite (le 10 et le 12 chiffres) ou vous dire la 5e et la 7e plus de chiffres significatifs.

int mask =  0x0E00;  //0000 1110 0000 0000;
int extract = mask & number;

résultats dans:

extract = 0000 1010 0000 0000

Vous pouvez faire

if (extract == 0x0A00 /*0000 1010 0000 0000*/){}

pour tester, ou:

if (( extract >> 9 ) == 0x05){}

Les deux états dans le si retournera true avec votre numéro de l'échantillon.

Généralement avec un masque, vous trouverez vous-même un test sur un seul chiffre. Vous pouvez utiliser une fonction comme ceci pour le tester:

bool digit_value( unsigned int number, unsigned int digit)
{
    return (1 << digit) & number;
}

int main()
{
    unsigned int number = 0x1A4B;
    int should_be_three = 0;
    should_be_three +=  digit_value(number, 10);
    should_be_three += !digit_value(number, 11);
    should_be_three +=  digit_value(number, 12);
    printf("%s", (should_be_three == 3?"it worked":"it didn't work"));
    return 0;
}

OriginalL'auteur Baldrickk

Il peut être plus simple pour vérifier les bits un par un, pas tous à la fois.
Au premier abord, vous créez un masque pour les intéressés bits:

int fifthBitMask = 1 << 4;
int fifthBitResult = number & fifthBitMask;

int seventhBitMask = 1 << 6;
int seventhBitResult = number & seventhBitMask;

Maintenant, vous pouvez comparer les résultats avec zéro OU avec un masque.
En comparant avec zéro peut être omis, de sorte que vous pouvez simplement utiliser simple si:

if (fifthBitResult && seventhBitResult)
{
    //your code here
}

Aussi, vous pouvez comparer avec les masques. Après l'opération &, dans la suite fixera seulement bits, ce qui a été défini dans le masque.
Donc, il pourrait comme ceci:
si (fifthBitResult == fifthBitMask && seventhBitResult == seventhBitMask)
{
//votre code ici
}

Donc, si le résultat de l'opération est égal à un masque, vous pouvez le faire avec une seule opération:

int mask = 0x5 << 4; //0x5 is hex representation of 101b
int result = number & mask;
if (result == mask)
{
    //your code here
}

OriginalL'auteur noktigula