C / C ++ memeriksa apakah satu bit disetel, yaitu variabel int

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

Apakah ada cara untuk memeriksa apakah bit 3 dalam suhu 1 atau 0 tanpa sedikit pergeseran dan masking.

Hanya ingin tahu apakah ada fungsi bawaan untuk ini, atau saya terpaksa menulisnya sendiri.

Di C, jika Anda ingin menyembunyikan manipulasi bit, Anda dapat menulis makro:

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

dan gunakan cara ini untuk memeriksa bit ^ke- n dari ujung kanan:

CHECK_BIT(temp, n - 1)

Di C ++, Anda dapat menggunakan std :: bitset .

Periksa apakah bit N (mulai dari 0) disetel:

temp & (1 << N)

Tidak ada fungsi bawaan untuk ini.

Saya hanya akan menggunakan std :: bitset jika itu C ++. Sederhana. Mudah. Tidak ada kesempatan untuk kesalahan bodoh.

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

atau bagaimana dengan kekonyolan ini

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

Apa yang dilakukan jawaban yang dipilih sebenarnya salah. Fungsi di bawah ini akan mengembalikan posisi bit atau 0 tergantung pada apakah bit benar-benar diaktifkan. Ini bukan yang diminta poster itu.

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

Inilah yang awalnya dicari poster itu. Fungsi di bawah ini akan mengembalikan 1 atau 0 jika bit diaktifkan dan bukan posisinya.

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

Ya, saya tahu saya tidak "harus" melakukannya dengan cara ini. Tapi saya biasanya menulis:

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

Misalnya:

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

Antara lain, pendekatan ini:

• Mengakomodasi 8/16/32/64 bit integer.
• Mendeteksi panggilan IsBitSet (int32, int64) tanpa sepengetahuan & persetujuan saya.
• Template Inline, jadi tidak ada fungsi yang memanggil overhead.
• const & referensi, jadi tidak ada yang perlu diduplikasi / disalin. Dan kami dijamin bahwa kompilator akan menerima kesalahan ketik apa pun yang mencoba mengubah argumen.
• 0! = Membuat kode lebih jelas & jelas. Poin utama dalam menulis kode adalah selalu berkomunikasi dengan jelas dan efisien dengan programmer lain, termasuk mereka yang memiliki keterampilan lebih rendah.
• Meskipun tidak berlaku untuk kasus khusus ini ... Secara umum, fungsi template menghindari masalah mengevaluasi argumen beberapa kali. Masalah yang diketahui dengan beberapa makro #define.
  Misalnya: #define ABS (X) (((X) <0)? - (X): (X))
        ABS (i ++);

Menurut deskripsi bidang bit ini , terdapat metode untuk menentukan dan mengakses bidang secara langsung. Contoh dalam entri ini adalah:

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

Juga, ada peringatan di sana:

Namun, anggota bit dalam struct memiliki kelemahan praktis. Pertama, urutan bit dalam memori bergantung pada arsitektur dan aturan padding memori bervariasi dari compiler ke compiler. Selain itu, banyak kompiler populer menghasilkan kode yang tidak efisien untuk membaca dan menulis anggota bit, dan ada masalah keamanan thread yang berpotensi parah terkait dengan bidang bit (terutama pada sistem multiprosesor) karena fakta bahwa sebagian besar mesin tidak dapat memanipulasi kumpulan bit yang berubah-ubah dalam memori, tetapi harus memuat dan menyimpan seluruh kata.

Anda dapat menggunakan Bitset - http://www.cppreference.com/wiki/stl/bitset/start .

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

Ada, yaitu instruksi intrinsik _bittest .

Saya menggunakan ini:

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

di mana "pos" didefinisikan sebagai 2 ^ n (ig 1,2,4,8,16,32 ...)

Mengembalikan: 1 jika benar 0 jika salah

saya mencoba membaca integer 32-bit yang menentukan bendera untuk objek dalam PDF dan ini tidak berfungsi untuk saya

yang memperbaikinya adalah mengubah definisi:

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

operan & mengembalikan integer dengan flag yang keduanya ada di 1, dan tidak mentransmisikan dengan benar ke dalam boolean, ini berhasil

Anda bisa "mensimulasikan" perpindahan dan pemaskeran: if ((0x5e / (2 * 2 * 2))% 2) ...

Untuk solusi khusus x86 tingkat rendah, gunakan TEST x86 opcode .

Kompiler Anda harus mengubah _bittest menjadi ini ...

Mengapa tidak menggunakan sesuatu yang sederhana seperti ini?

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

OUTPUT: biner: 11111111

jika Anda hanya ingin cara kode keras yang nyata:

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

perhatikan hw ini tergantung dan anggap urutan bit ini 7654 3210 dan var adalah 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;
}

Hasil dalam:

1 0 1 0

Meskipun cukup terlambat untuk menjawabnya sekarang, ada cara sederhana untuk mengetahui apakah bit ke-N disetel atau tidak, cukup dengan menggunakan operator matematika POWER dan MODULUS.

Katakanlah kita ingin tahu apakah 'temp' memiliki bit ke-N atau tidak. Ekspresi boolean berikut akan menjadi true jika bit disetel, 0 jika tidak.

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

Perhatikan contoh berikut:

• suhu int = 0x5E; // dalam biner 0b1011110 // BIT 0 adalah LSB

Jika saya ingin tahu apakah bit ke-3 disetel atau tidak, saya mengerti

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

Jadi ekspresi mengembalikan nilai true, menunjukkan bit ke-3 disetel.

Salah satu pendekatan akan memeriksa dalam kondisi berikut:

if ( (mask >> bit ) & 1)

Program penjelasan akan menjadi:

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

Keluaran:

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 - Posisi bit dimulai dari 0.

mengembalikan 0 atau 1.

Saya membuat ini:

LATGbits.LATG0 = ((m & 0x8)> 0); // untuk memeriksa apakah bit-2 dari m adalah 1

cara tercepat adalah tabel pencarian untuk topeng