Comment vérifier mon drapeau d'octet?

StackOverflow https://stackoverflow.com/questions/127027

Question

J'utilise un octet pour stocker un drapeau tel que 10101010 et j'aimerais savoir comment vérifier qu'un bit spécifique est à 1 ou 0.

Était-ce utile?

La solution

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

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 & Lt; & Lt; 0) sera égal à 00000001, (1 & Lt; & Lt; 1) sera égal à 00000010, (1 & Lt; & ll; 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 32 bits.

L'opérateur au niveau des bits et (& amp;) donne un résultat dans lequel tous les bits n ° 1 des deux côtés sont définis. Exemples: 1111 & Amp; 0001 = 0001; 1111 & Amp; 0010 == 0010; 0000 & Amp; 0001 = 0000. Ainsi, l'expression (valeur & Amp; (1 & Lt; & Lt; bitindex)) renverra le masque binaire si le bit associé a la valeur 1, ou renverra 0 si le le bit est 0.

Enfin, nous vérifions simplement si le résultat est différent de zéro. (Cela pourrait en fait être omis, mais j'aime rendre cela explicite.)

Autres conseils

En tant qu'extension de @Daoks answer

Lors de la manipulation de bits, vraiment vous aide à avoir une très bonne connaissance de opérateurs au niveau des bits .

Aussi le bitwise " ET " L'opérateur en C est &, donc ce que vous voulez faire est: 

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 bitwise & "; AND &"; (& amp; en C) pour vérifier si un bit particulier a été activé ou non. J'ai également utilisé deux manières différentes de formuler des nombres binaires. Je vous recommande vivement de consulter le lien Wikipedia ci-dessus.

Vous pouvez utiliser un opérateur AND. Par 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 en troisième position sur 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 <bitset>
//...
std::bitset<8> flags(someVariable);

comme alors vous pouvez vérifier et définir des drapeaux en utilisant 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;
}

Vous avez ici une structure simple avec quatre champs de 1 bit chacun. Ensuite, vous pouvez écrire votre code en utilisant un simple accès à 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 matière de petite taille et de code lisible, car vous pouvez attribuer à vos champs des noms significatifs à l'intérieur de la structure.

Personne ne s'est trompé jusqu'à présent, 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 une valeur autre que zéro, le bit est activé. 

byte THIRDBIT = 4; // 4 = 00000100 i.e 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 binaire. 

if (var & 0x08) {
  /* the fourth bit is set */
}
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top