C / C ++ controlla se un bit è impostato in, cioè int variabile

int temp = 0x5E; // in binary 0b1011110.

Esiste un modo per verificare se il bit 3 in temp è 1 o 0 senza cambio di bit e mascheramento.

Voglio solo sapere se c'è qualche funzione incorporata per questo, o sono costretto a scriverne una io stesso.

In C, se vuoi nascondere la manipolazione dei bit, puoi scrivere una macro:

#define CHECK_BIT(var,pos) ((var) & (1<<(pos)))

e usalo in questo modo per controllare l' ^ennesimo bit dall'estremità destra:

CHECK_BIT(temp, n - 1)

In C ++, puoi usare std :: bitset .

Verificare se il bit N (a partire da 0) è impostato:

temp & (1 << N)

Non esiste una funzione incorporata per questo.

Vorrei solo usare uno std :: bitset se è C ++. Semplice. Straight-forward. Nessuna possibilità di errori stupidi.

typedef std::bitset<sizeof(int)> IntBits;
bool is_set = IntBits(value).test(position);

o che ne dici di questa stupidità

template<unsigned int Exp>
struct pow_2 {
    static const unsigned int value = 2 * pow_2<Exp-1>::value;
};

template<>
struct pow_2<0> {
    static const unsigned int value = 1;
};

template<unsigned int Pos>
bool is_bit_set(unsigned int value)
{
    return (value & pow_2<Pos>::value) != 0;
} 

bool result = is_bit_set<2>(value);

Sì, lo so che non "devo" farlo in questo modo. Ma di solito scrivo:

    /* Return type (8/16/32/64 int size) is specified by argument size. */
template<class TYPE> inline TYPE BIT(const TYPE & x)
{ return TYPE(1) << x; }

template<class TYPE> inline bool IsBitSet(const TYPE & x, const TYPE & y)
{ return 0 != (x & y); }

Per esempio:

IsBitSet( foo, BIT(3) | BIT(6) );  // Checks if Bit 3 OR 6 is set.

Tra le altre cose, questo approccio:

• Ospita numeri interi a 8/16/32/64 bit.
• Rileva le chiamate IsBitSet (int32, int64) a mia insaputa e senza il mio consenso.
• Modello inline, quindi nessuna funzione che chiama overhead.
• const e riferimenti, quindi non è necessario duplicare / copiare nulla . E siamo garantiti che il compilatore rileverà qualsiasi errore di battitura che tenti di cambiare gli argomenti.
• 0! = Rende il codice più chiaro e ovvio. Il punto principale per scrivere codice è sempre quello di comunicare in modo chiaro ed efficiente con altri programmatori, compresi quelli di minore abilità.
• Sebbene non sia applicabile a questo caso particolare ... In generale, le funzioni basate su modelli evitano il problema di valutare gli argomenti più volte. Un problema noto con alcune macro #define.
  Ad esempio: #define ABS (X) (((X) <0)? - (X): (X))
        ABS (i ++);

Quello che sta facendo la risposta selezionata è effettivamente sbagliato. La funzione seguente restituirà la posizione del bit o 0 a seconda che il bit sia effettivamente abilitato. Questo non è ciò che chiedeva il poster.

#define CHECK_BIT(var,pos) ((var) & (1<<(pos)))

Ecco cosa cercava originariamente il poster. La funzione seguente restituirà 1 o 0 se il bit è abilitato e non la posizione.

#define CHECK_BIT(var,pos) (((var)>>(pos)) & 1)

Secondo questa descrizione dei campi di bit , esiste un metodo per definire e accedere direttamente ai campi. L'esempio in questa voce va:

struct preferences {
    unsigned int likes_ice_cream : 1;
    unsigned int plays_golf : 1;
    unsigned int watches_tv : 1;
    unsigned int reads_books : 1;
}; 

struct preferences fred;

fred.likes_ice_cream = 1;
fred.plays_golf = 1;
fred.watches_tv = 1;
fred.reads_books = 0;

if (fred.likes_ice_cream == 1)
    /* ... */

Inoltre, c'è un avviso lì:

Tuttavia, i membri di bit nelle strutture presentano svantaggi pratici. Innanzitutto, l'ordine dei bit in memoria dipende dall'architettura e le regole di riempimento della memoria variano da compilatore a compilatore. Inoltre, molti compilatori popolari generano codice inefficiente per la lettura e la scrittura di membri di bit, e ci sono problemi di sicurezza dei thread potenzialmente gravi relativi ai campi di bit (specialmente su sistemi multiprocessore) a causa del fatto che la maggior parte delle macchine non può manipolare set arbitrari di bit in memoria, ma deve invece caricare e memorizzare intere parole.

Puoi utilizzare un Bitset - http://www.cppreference.com/wiki/stl/bitset/start .

Usa std :: bitset

#include <bitset>
#include <iostream>

int main()
{
    int temp = 0x5E;
    std::bitset<sizeof(int)*CHAR_BITS>   bits(temp);

    // 0 -> bit 1
    // 2 -> bit 3
    std::cout << bits[2] << std::endl;
}

C'è, vale a dire l' istruzione intrinseca _bittest .

Io uso questo:

#define CHECK_BIT(var,pos) ( (((var) & (pos)) > 0 ) ? (1) : (0) )

dove "pos" è definito come 2 ^ n (ig 1,2,4,8,16,32 ...)

Restituisce: 1 se vero 0 se falso

stavo cercando di leggere un numero intero a 32 bit che definiva i flag per un oggetto nei PDF e questo non funzionava per me

ciò che ha risolto stava cambiando la definizione:

#define CHECK_BIT(var,pos) ((var & (1 << pos)) == (1 << pos))

l'operando & restituisce un numero intero con i flag che hanno entrambi in 1, e non è stato trasmesso correttamente in booleano, questo ha funzionato

Puoi "simulare" lo spostamento e il mascheramento: if ((0x5e / (2 * 2 * 2))% 2) ...

Per la soluzione specifica x86 di basso livello, utilizzare il codice operativo x86 TEST .

Il tuo compilatore dovrebbe trasformare _bittest in questo però ...

Perché non usare qualcosa di così semplice come questo?

uint8_t status = 255;
cout << "binary: ";

for (int i=((sizeof(status)*8)-1); i>-1; i--)
{
  if ((status & (1 << i)))
  {
    cout << "1";
  } 
  else
  {
    cout << "0";
  }
}

USCITA: binario: 11111111

se vuoi solo un vero modo hard coded:

 #define IS_BIT3_SET(var) ( ((var) & 0x04) == 0x04 )

nota questo hw dipendente e assume che questo ordine di bit 7654 3210 e var sia 8 bit.

#include "stdafx.h"
#define IS_BIT3_SET(var) ( ((var) & 0x04) == 0x04 )
int _tmain(int argc, _TCHAR* argv[])
{
    int temp =0x5E;
    printf(" %d \n", IS_BIT3_SET(temp));
    temp = 0x00;
    printf(" %d \n", IS_BIT3_SET(temp));
    temp = 0x04;
    printf(" %d \n", IS_BIT3_SET(temp));
    temp = 0xfb;
    printf(" %d \n", IS_BIT3_SET(temp));
    scanf("waitng %d",&temp);

    return 0;
}

Risultati in:

1 0 1 0

Anche se ora è abbastanza tardi per rispondere, c'è un modo semplice per scoprire se l'ennesimo bit è impostato o meno, semplicemente usando gli operatori matematici POWER e MODULUS.

Supponiamo di voler sapere se 'temp' ha l'ennesimo bit impostato o meno. La seguente espressione booleana restituirà true se il bit è impostato, 0 in caso contrario.

• (temp MODULUS 2 ^ N + 1> = 2 ^ N)

Considera il seguente esempio:

• int temp = 0x5E; // in binario 0b1011110 // BIT 0 è LSB

Se voglio sapere se il terzo bit è impostato o meno, ottengo

• (94 MODULUS 16) = 14> 2 ^ 3

Quindi l'espressione restituisce vero, indicando che il terzo bit è impostato.

Un approccio verificherà la seguente condizione:

if ( (mask >> bit ) & 1)

Un programma di spiegazione sarà:

#include <stdio.h>

unsigned int bitCheck(unsigned int mask, int pin);

int main(void){
   unsigned int mask = 6;  // 6 = 0110
   int pin0 = 0;
   int pin1 = 1;
   int pin2 = 2;
   int pin3 = 3;
   unsigned int bit0= bitCheck( mask, pin0);
   unsigned int bit1= bitCheck( mask, pin1);
   unsigned int bit2= bitCheck( mask, pin2);
   unsigned int bit3= bitCheck( mask, pin3);

   printf("Mask = %d ==>>  0110\n", mask);

   if ( bit0 == 1 ){
      printf("Pin %d is Set\n", pin0);
   }else{
      printf("Pin %d is not Set\n", pin0);
   }

    if ( bit1 == 1 ){
      printf("Pin %d is Set\n", pin1);
   }else{
      printf("Pin %d is not Set\n", pin1);
   }

   if ( bit2 == 1 ){
      printf("Pin %d is Set\n", pin2);
   }else{
      printf("Pin %d is not Set\n", pin2);
   }

   if ( bit3 == 1 ){
      printf("Pin %d is Set\n", pin3);
   }else{
      printf("Pin %d is not Set\n", pin3);
   }
}

unsigned int bitCheck(unsigned int mask, int bit){
   if ( (mask >> bit ) & 1){
      return 1;
   }else{
      return 0;
   }
}

Produzione:

Mask = 6 ==>>  0110
Pin 0 is not Set
Pin 1 is Set
Pin 2 is Set
Pin 3 is not Set

#define CHECK_BIT(var,pos) ((var>>pos) & 1)

pos - Posizione del bit a partire da 0.

restituisce 0 o 1.

Faccio questo:

LATGbits.LATG0 = ((m & 0x8)> 0); // per verificare se il bit-2 di m è 1

il modo più veloce sembra essere una tabella di ricerca per le maschere