C / C ++ sprawdź, czy ustawiony jest jeden bit, tj. Zmienna int

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

Czy istnieje taki sposób, aby sprawdzić, czy bit 3 w temp jest 1 czy 0 bez przesuwania bitów i maskowania.

Chcę tylko wiedzieć, czy jest do tego jakaś wbudowana funkcja, czy też jestem zmuszony napisać ją sam.

W C, jeśli chcesz ukryć manipulację bitami, możesz napisać makro:

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

i użyj go w ten sposób, aby sprawdzić n- ^ty bit od prawego końca:

CHECK_BIT(temp, n - 1)

W C ++ możesz użyć std :: bitset .

Sprawdź, czy ustawiony jest bit N (zaczynając od 0):

temp & (1 << N)

Nie ma do tego wbudowanej funkcji.

Po prostu użyłbym zestawu std :: bitset, jeśli jest to C ++. Prosty. Bezpośredni. Nie ma szans na głupie błędy.

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

albo co powiesz na tę głupotę

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);

Tak, wiem, że nie „muszę” tego robić w ten sposób. Ale zazwyczaj piszę:

    /* 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); }

Na przykład:

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

Między innymi takie podejście:

• Obsługuje 8/16/32/64 bitowe liczby całkowite.
• Wykrywa wywołania IsBitSet (int32, int64) bez mojej wiedzy i zgody.
• Wbudowany szablon, więc żadna funkcja nie wywołuje obciążenia.
• const i referencje, więc nic nie musi być powielane / kopiowane. I mamy gwarancję, że kompilator wykryje wszelkie literówki, które próbują zmienić argumenty.
• 0! = Sprawia, że ​​kod jest bardziej przejrzysty i oczywisty. Głównym celem pisania kodu jest zawsze jasna i wydajna komunikacja z innymi programistami, w tym z mniejszymi umiejętnościami.
• Chociaż nie ma to zastosowania w tym konkretnym przypadku ... Ogólnie funkcje oparte na szablonach pozwalają uniknąć problemu wielokrotnego oceniania argumentów. Znany problem z niektórymi makrami #define.
  Np .: # zdefiniować ABS (X) (((X) <0)? - (X): (X))
        ABS (i ++);

To, co robi wybrana odpowiedź, jest w rzeczywistości złe. Poniższa funkcja zwróci pozycję bitu lub 0 w zależności od tego, czy bit jest faktycznie włączony. Nie o to prosił plakat.

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

Oto, czego pierwotnie szukał plakat. Poniższa funkcja zwróci 1 lub 0, jeśli bit jest włączony, a nie pozycja.

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

Zgodnie z tym opisem pól bitowych istnieje metoda bezpośredniego definiowania i uzyskiwania dostępu do pól. Przykład w tym wpisie brzmi:

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)
    /* ... */

Jest tam również ostrzeżenie:

Jednak elementy bitowe w strukturach mają praktyczne wady. Po pierwsze, kolejność bitów w pamięci zależy od architektury, a zasady wypełniania pamięci różnią się w zależności od kompilatora. Ponadto wiele popularnych kompilatorów generuje nieefektywny kod do odczytywania i zapisywania składowych bitów, a także istnieją potencjalnie poważne problemy z bezpieczeństwem wątków związane z polami bitów (szczególnie w systemach wieloprocesorowych), ponieważ większość maszyn nie może manipulować dowolnymi zestawami bitów w pamięci, ale zamiast tego musi ładować i przechowywać całe słowa.

Możesz użyć Bitsetu - http://www.cppreference.com/wiki/stl/bitset/start .

Użyj 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;
}

Jest, a mianowicie najbardziej zawzięta instrukcja wewnętrzna.

Używam tego:

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

gdzie „pos” jest zdefiniowane jako 2 ^ n (ig 1,2,4,8,16,32 ...)

Zwraca: 1 jeśli prawda 0 jeśli fałsz

Próbowałem odczytać 32-bitową liczbę całkowitą, która definiowała flagi obiektu w plikach PDF, ale to nie działało dla mnie

co naprawiło to zmiana definicji:

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

operand & zwraca liczbę całkowitą z flagami, które obie mają w 1, i nie był poprawnie rzutowany na wartość logiczną, to załatwiło sprawę

Możesz "zasymulować" przesuwanie i maskowanie: jeśli ((0x5e / (2 * 2 * 2))% 2) ...

W przypadku rozwiązania niskiego poziomu specyficznego dla x86 użyj kodu operacji x86 TEST .

Twój kompilator powinien jednak zmienić _bittest w to ...

Dlaczego nie użyć czegoś tak prostego jak to?

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";
  }
}

WYJŚCIE: binarne: 11111111

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

pos - pozycja bitu zaczynająca się od 0.

zwraca 0 lub 1.

jeśli chcesz naprawdę zakodować sposób:

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

zwróć uwagę na to zależne od hw i zakłada, że ​​ta kolejność bitów 7654 3210, a var wynosi 8 bitów.

#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;
}

Prowadzi do:

1 0 1 0

Chociaż jest już dość późno, aby odpowiedzieć teraz, istnieje prosty sposób, aby sprawdzić, czy N-ty bit jest ustawiony, czy nie, po prostu za pomocą operatorów matematycznych POWER i MODULUS.

Powiedzmy, że chcemy wiedzieć, czy „temp” ma ustawiony N-ty bit, czy nie. Poniższe wyrażenie boolowskie da wartość true, jeśli bit jest ustawiony, 0 w przeciwnym razie.

• (moduł temp. 2 ^ N + 1> = 2 ^ N)

Rozważmy następujący przykład:

• int temp = 0x5E; // binarnie 0b1011110 // BIT 0 to LSB

Jeśli chcę wiedzieć, czy 3. bit jest ustawiony, czy nie, otrzymuję

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

Zatem wyrażenie zwraca prawdę, wskazując, że ustawiono trzeci bit.

Jedną z metod będzie sprawdzenie w ramach następującego warunku:

if ( (mask >> bit ) & 1)

Program wyjaśniający będzie:

#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;
   }
}

Wynik:

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

Robię to:

LATGbits.LATG0 = ((m & 0x8)> 0); // aby sprawdzić, czy bit-2 z m to 1

najszybszym sposobem wydaje się być tablica wyszukiwania masek