Come controllare il mio flag di byte?

Question

Uso un byte per memorizzare alcuni flag come 10101010 e vorrei sapere come verificare che un bit specifico sia 1 o 0.

Answer 1

Ecco una funzione che può essere utilizzata per testare qualsiasi bit desiderato:

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

Un po 'di spiegazione:

L'operatore di spostamento a sinistra (< <) viene utilizzato per creare una maschera di bit. (1 & Lt; & Lt; 0) sarà uguale a 00000001, (1 & Lt; & Lt; 1) sarà uguale a 00000010, (1 & Lt; < 3) sarà uguale a 00001000, ecc. Quindi uno spostamento di 0 verifica il bit più a destra. Uno spostamento di 31 sarebbe il bit più a sinistra di un valore a 32 bit.

L'operatore bit per bit (& amp;) fornisce un risultato in cui sono impostati tutti i bit 1 su entrambi i lati. Esempi: 1111 & Amp; 0001 = 0001; 1111 & Amp; 0010 == 0010; 0000 & Amp; 0001 = 0000. Quindi, l'espressione (valore & Amp; (1 & Lt; & Lt; bitindex)) restituirà la maschera di bit se il bit associato ha un valore di 1 o restituirà 0 se il valore associato il bit è 0.

Infine, controlliamo solo se il risultato è diverso da zero. (Questo in realtà potrebbe essere lasciato fuori, ma mi piace renderlo esplicito.)

Answer 2

Come estensione della risposta di @Daoks

Quando si esegue la manipolazione di bit, davvero aiuta ad avere una conoscenza molto solida di operatori bit a bit .

Anche il bit " E " l'operatore in C è &, quindi quello che vuoi fare è:

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
}

Sopra ho usato il bit " AND " (& amp; in C) per verificare se è stato impostato o meno un determinato bit. Ho anche usato due modi diversi di formulare numeri binari. Consiglio vivamente di consultare il link Wikipedia sopra.

Answer 3

È possibile utilizzare un operatore AND. Esempio hai: 10101010 e vuoi controllare il terzo bit che puoi fare: (10101010 E 00100000) e se ottieni 00100000 sai che hai la bandiera in terza posizione a 1.

Answer 4

Se si utilizza C ++ e la libreria standard è consentita, suggerirei di archiviare i flag in un bitset:

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

come allora puoi controllare e impostare flag usando l'operatore di indicizzazione [].

Answer 5

La risposta di Kristopher Johnson è molto buona se ti piace lavorare con singoli campi come questo. Preferisco semplificare la lettura del codice utilizzando i campi di bit in C.

Ad esempio:

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

Qui hai una semplice struttura con quattro campi, ciascuno di dimensioni di 1 bit. Quindi puoi scrivere il tuo codice usando un semplice accesso alla struttura.

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

Ottieni lo stesso vantaggio di piccole dimensioni, oltre al codice leggibile perché puoi dare ai tuoi campi nomi significativi all'interno della struttura.

Answer 6

Finora nessuno ha sbagliato, ma per dare un metodo per controllare un bit arbitrario:

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

Se la funzione restituisce un valore diverso da zero, il bit è impostato.

Answer 7

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
}

Answer 8

puoi fare come dice Daok e fai un po 'alla volta OR al risultato dell'operazione AND precedente. In questo caso avrai un risultato finale di 1 o 0.

Answer 9

Tradizionalmente, per verificare se è impostato il bit più basso, sarà simile a:

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

Answer 10

Usa un bit per bit (non logico!) e per confrontare il valore con una maschera di bit.

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