Comment vérifier mon drapeau d’octet?

J’utilise un octet pour stocker un indicateur comme 10101010 et j’aimerais savoir comment vérifier qu’un bit spécifique est à 1 ou à 0 .

    Voici une fonction qui peut être utilisée pour tester n’importe quel bit désiré:

     bool is_bit_set(unsigned value, unsigned bitindex) { return (value & (1 << bitindex)) != 0; } 

    Un peu d'explication:

    L'opérateur de décalage à gauche (<<) est utilisé pour créer un masque de bits. (1 << 0) sera égal à 00000001, (1 << 1) sera égal à 00000010, (1 << 3) sera égal à 00001000, etc. Ainsi, un décalage de 0 teste le bit le plus à droite. Un décalage de 31 serait le bit le plus à gauche d'une valeur de 32 bits.

    Le bit et l'opérateur (&) donne un résultat où tous les bits qui sont 1 des deux côtés sont définis. Exemples: 1111 & 0001 = 0001; 1111 & 0010 == 0010; 0000 & 0001 = 0000. Ainsi, l'expression (valeur & (1

    Enfin, nous vérifions simplement si le résultat est non nul. (Cela pourrait en fait être laissé de côté, mais j'aime bien le rendre explicite.)

    En tant qu’extension de @Daoks answer

    Lors de la manipulation de bits, il est vraiment utile d’avoir une très bonne connaissance des opérateurs au niveau des bits .

    De plus, l’opérateur “AND” de C dans Bitwise est & , vous voulez donc:

     unsigned char a = 0xAA; // 10101010 in hex unsigned char b = (1 << bitpos); //Where bitpos is the position you want to check if(a & b) { //bit set } else { //not set } 

    Ci-dessus, j'ai utilisé le bit "AND" (& en C) pour vérifier si un bit particulier était activé ou non. J'ai également utilisé deux manières différentes de formuler des nombres binarys. Je vous recommande vivement de consulter le lien Wikipedia ci-dessus.

    Vous pouvez utiliser un opérateur AND. Exemple vous avez: 10101010 et vous voulez vérifier le troisième bit que vous pouvez faire: (10101010 ET 00100000) et si vous obtenez 00100000, vous savez que vous avez le drapeau à la troisième position à 1.

    Si vous utilisez C ++ et que la bibliothèque standard est autorisée, nous vous suggérons de stocker vos indicateurs dans un jeu de bits:

     #include  //... std::bitset<8> flags(someVariable); 

    Vous pouvez ensuite vérifier et définir des indicateurs à l’aide de l’opérateur d’indexation [].

    La réponse de Kristopher Johnson est très bonne si vous aimez travailler avec des domaines individuels comme celui-ci. Je préfère rendre le code plus facile à lire en utilisant des champs de bits en C.

    Par exemple:

     struct fieldsample { unsigned short field1 : 1; unsigned short field2 : 1; unsigned short field3 : 1; unsigned short field4 : 1; } 

    Ici vous avez une structure simple avec quatre champs de 1 bit chacun. Ensuite, vous pouvez écrire votre code en utilisant un access simple à la structure.

     void codesample() { //Declare the struct on the stack. fieldsample fields; //Initialize values. fields.f1 = 1; fields.f2 = 0; fields.f3 = 0; fields.f4 = 1; ... //Check the value of a field. if(fields.f1 == 1) {} ... } 

    Vous bénéficiez du même avantage en termes de petite taille et de code lisible, car vous pouvez atsortingbuer à vos champs des noms significatifs à l’intérieur de la structure.

    Personne ne s’est trompé jusqu’ici, sauf pour donner une méthode pour vérifier un bit arbitraire:

     int checkBit( byte in, int bit ) { return in & ( 1 << bit ); } 

    Si la fonction renvoie non nul, le bit est activé.

     byte THIRDBIT = 4; // 4 = 00000100 ie third bit is set int isThirdBitSet(byte in) { return in & THIRDBIT; // Returns 1 if the third bit is set, 0 otherwise } 

    vous pouvez faire ce que Daok dit et vous faites un peu de OU à la suite de l’opération AND précédente. Dans ce cas, vous aurez un résultat final de 1 ou 0.

    Traditionnellement, pour vérifier si le bit le plus bas est défini, cela ressemblera à quelque chose comme:

     int MY_FLAG = 0x0001; if ((value & MY_FLAG) == MY_FLAG) doSomething(); 

    Utilisez un bit à bit (pas logique!) Et comparez la valeur à un masque de bits.

     if (var & 0x08) { /* the fourth bit is set */ }