C / C ++ prüft, ob ein Bit gesetzt ist, dh int Variable

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

Gibt es eine Möglichkeit zu überprüfen, ob Bit 3 in Temp 1 oder 0 ist, ohne dass Bit verschoben und maskiert wird?

Ich möchte nur wissen, ob es dafür eine eingebaute Funktion gibt, oder bin ich gezwungen, selbst eine zu schreiben.

Wenn Sie in C die Bitmanipulation ausblenden möchten, können Sie ein Makro schreiben:

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

und verwenden Sie es auf diese Weise, um das n- ^te Bit vom rechten Ende aus zu überprüfen :

CHECK_BIT(temp, n - 1)

In C ++ können Sie std :: bitset verwenden .

Überprüfen Sie, ob Bit N (ab 0) gesetzt ist:

temp & (1 << N)

Hierfür gibt es keine eingebaute Funktion.

Ich würde nur ein std :: bitset verwenden, wenn es C ++ ist. Einfach. Einfach. Keine Chance für dumme Fehler.

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

oder wie wäre es mit dieser Albernheit

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

Ja, ich weiß , ich weiß nicht „haben“ es auf diese Weise zu tun. Aber ich schreibe normalerweise:

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

Z.B:

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

Dieser Ansatz ist unter anderem:

• Platz für 8/16/32/64-Bit-Ganzzahlen.
• Erkennt IsBitSet (int32, int64) -Anrufe ohne mein Wissen und meine Zustimmung.
• Inline-Vorlage, also kein Funktionsaufruf Overhead.
• const & Referenzen, also nichts Bedarf dupliziert / kopiert werden. Und wir sind garantiert, dass der Compiler alle Tippfehler aufnimmt, die versuchen, die Argumente zu ändern.
• 0! = Macht den Code klarer und offensichtlicher. Der wichtigste Punkt beim Schreiben von Code ist immer die klare und effiziente Kommunikation mit anderen Programmierern, einschließlich solchen mit geringeren Fähigkeiten.
• Obwohl dies für diesen speziellen Fall nicht anwendbar ist ... Im Allgemeinen vermeiden Vorlagenfunktionen das Problem der mehrfachen Auswertung von Argumenten. Ein bekanntes Problem mit einigen # Define-Makros.
  ZB: # ABS (X) definieren (((X) <0) - (X): (X))
        ABS (i ++);

Was die ausgewählte Antwort tut, ist tatsächlich falsch. Die folgende Funktion gibt die Bitposition oder 0 zurück, je nachdem, ob das Bit tatsächlich aktiviert ist. Dies ist nicht das, wonach das Poster gefragt hat.

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

Hier ist, wonach das Poster ursprünglich gesucht hat. Die folgende Funktion gibt entweder eine 1 oder eine 0 zurück, wenn das Bit aktiviert ist und nicht die Position.

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

Nach dieser Beschreibung von Bitfeldern gibt es eine Methode zum direkten Definieren und Zugreifen auf Felder. Das Beispiel in diesem Eintrag lautet:

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

Außerdem gibt es dort eine Warnung:

Bitelemente in Strukturen haben jedoch praktische Nachteile. Erstens ist die Reihenfolge der Bits im Speicher architekturabhängig und die Speicherauffüllregeln variieren von Compiler zu Compiler. Darüber hinaus generieren viele gängige Compiler ineffizienten Code zum Lesen und Schreiben von Bitelementen, und es gibt potenziell schwerwiegende Thread-Sicherheitsprobleme in Bezug auf Bitfelder (insbesondere auf Multiprozessorsystemen), da die meisten Maschinen keine beliebigen Sätze von Bits im Speicher manipulieren können. sondern muss stattdessen ganze Wörter laden und speichern.

Sie können ein Bitset verwenden - http://www.cppreference.com/wiki/stl/bitset/start .

Verwenden Sie 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;
}

Es gibt nämlich die kleinste intrinsische Anweisung.

Ich benutze das:

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

wobei "pos" definiert ist als 2 ^ n (ig 1,2,4,8,16,32 ...)

Rückgabe: 1 wenn wahr 0 wenn falsch

Ich habe versucht, eine 32-Bit-Ganzzahl zu lesen, die die Flags für ein Objekt in PDFs definiert, und das hat bei mir nicht funktioniert

Was behoben wurde, war die Änderung der Definition:

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

Der Operand & gibt eine Ganzzahl mit den Flags zurück, die beide in 1 haben, und es wurde nicht richtig in Boolesche Werte umgewandelt. Dies hat den Trick getan

Sie können das Verschieben und Maskieren "simulieren": if ((0x5e / (2 * 2 * 2))% 2) ...

Verwenden Sie für die Low-Level-x86-spezifische Lösung den x86- TEST- Opcode.

Ihr Compiler sollte _bittest jedoch in dieses verwandeln ...

Warum nicht so etwas Einfaches verwenden?

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

AUSGABE: binär: 11111111

Wenn Sie nur einen wirklich hartcodierten Weg wollen:

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

Beachten Sie, dass dies hw-abhängig ist und diese Bitreihenfolge 7654 3210 annimmt und var 8 Bit ist.

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

Ergebnisse in:

1 0 1 0

Obwohl es ziemlich spät ist, jetzt zu antworten, gibt es eine einfache Möglichkeit, herauszufinden, ob das N-te Bit gesetzt ist oder nicht, indem einfach die mathematischen Operatoren POWER und MODULUS verwendet werden.

Nehmen wir an, wir möchten wissen, ob für 'temp' das N-te Bit gesetzt ist oder nicht. Der folgende boolesche Ausdruck gibt true, wenn das Bit gesetzt ist, andernfalls 0.

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

Betrachten Sie das folgende Beispiel:

• int temp = 0x5E; // in binär 0b1011110 // BIT 0 ist LSB

Wenn ich wissen will, ob das 3. Bit gesetzt ist oder nicht, bekomme ich

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

Der Ausdruck gibt also true zurück und zeigt an, dass das 3. Bit gesetzt ist.

Ein Ansatz besteht darin, unter folgenden Bedingungen zu prüfen:

if ( (mask >> bit ) & 1)

Ein Erklärungsprogramm wird sein:

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

Ausgabe:

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 - Bitposition ab 0.

gibt 0 oder 1 zurück.

Ich mache das:

LATGbits.LATG0 = ((m & 0x8)> 0); // um zu überprüfen, ob Bit-2 von m 1 ist

Der schnellste Weg scheint eine Nachschlagetabelle für Masken zu sein