C / C ++ vérifie si un bit est défini dans, c.-à-d. Variable int

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

Existe-t-il un moyen de vérifier si le bit 3 de temp est 1 ou 0 sans décalage de bit ni masquage.

Je veux juste savoir s'il existe une fonction intégrée pour cela, ou suis-je obligé d'en écrire une moi-même.

En C, si vous souhaitez masquer la manipulation de bits, vous pouvez écrire une macro:

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

et utilisez-le de cette façon pour vérifier le n ^ième bit à partir de l'extrémité droite:

CHECK_BIT(temp, n - 1)

En C ++, vous pouvez utiliser std :: bitset .

Vérifiez si le bit N (à partir de 0) est activé:

temp & (1 << N)

Il n'y a pas de fonction intégrée pour cela.

J'utiliserais juste un std :: bitset si c'est C ++. Facile. Simple. Aucune chance pour des erreurs stupides.

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

ou que diriez-vous de cette sottise

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

Ce que fait la réponse choisie est en fait faux. La fonction ci-dessous renverra la position du bit ou 0 selon que le bit est réellement activé. Ce n'est pas ce que demandait l'affiche.

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

Voici ce que l'affiche recherchait à l'origine. La fonction ci-dessous renverra un 1 ou un 0 si le bit est activé et non la position.

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

Ouais, je sais que je ne suis pas « avoir » le faire de cette façon. Mais j'écris habituellement:

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

Par exemple:

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

Entre autres, cette approche:

• Accepte les entiers 8/16/32/64 bits.
• Détecte les appels IsBitSet (int32, int64) à mon insu et sans mon consentement.
• Modèle intégré, donc aucune fonction appelant la surcharge.
• const & références, donc rien n'a besoin d'être dupliqué / copié. Et nous sommes assurés que le compilateur détectera toute faute de frappe qui tente de modifier les arguments.
• 0! = Rend le code plus clair et plus évident. Le point principal de l'écriture de code est toujours de communiquer clairement et efficacement avec d'autres programmeurs, y compris ceux de moindre compétence.
• Bien que cela ne s'applique pas à ce cas particulier ... En général, les fonctions basées sur des modèles évitent le problème de l'évaluation des arguments plusieurs fois. Un problème connu avec certaines macros #define.
  Par exemple: #define ABS (X) (((X) <0)? - (X): (X))
        ABS (i ++);

Selon cette description des champs de bits , il existe une méthode pour définir et accéder directement aux champs. L'exemple de cette entrée 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)
    /* ... */

En outre, il y a un avertissement là-bas:

Cependant, les membres bit dans les structures présentent des inconvénients pratiques. Premièrement, l'ordre des bits en mémoire dépend de l'architecture et les règles de remplissage de la mémoire varient d'un compilateur à l'autre. En outre, de nombreux compilateurs populaires génèrent du code inefficace pour la lecture et l'écriture de membres de bits, et il existe des problèmes de sécurité des threads potentiellement graves liés aux champs de bits (en particulier sur les systèmes multiprocesseurs) en raison du fait que la plupart des machines ne peuvent pas manipuler des ensembles arbitraires de bits en mémoire, mais doit à la place charger et stocker des mots entiers.

Vous pouvez utiliser un Bitset - http://www.cppreference.com/wiki/stl/bitset/start .

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

Il y a, à savoir l' instruction intrinsèque _bittest .

J'utilise ceci:

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

où "pos" est défini comme 2 ^ n (ig 1,2,4,8,16,32 ...)

Renvoie: 1 si vrai 0 si faux

J'essayais de lire un entier 32 bits qui définissait les indicateurs d'un objet dans les PDF et cela ne fonctionnait pas pour moi

ce qui a corrigé c'était de changer la définition:

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

l'opérande & renvoie un entier avec les indicateurs qui ont tous les deux en 1, et il n'a pas été converti correctement en booléen, cela a fait l'affaire

Vous pouvez "simuler" le décalage et le masquage: if ((0x5e / (2 * 2 * 2))% 2) ...

Pour la solution spécifique x86 de bas niveau, utilisez l' opcode x86 TEST .

Votre compilateur devrait cependant transformer _bittest en ceci ...

Pourquoi ne pas utiliser quelque chose d'aussi simple que cela?

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

SORTIE: binaire: 11111111

si vous voulez juste un vrai moyen codé en dur:

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

notez cette hw dépendant et suppose que cet ordre de bits 7654 3210 et var est de 8 bits.

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

Résulte en:

1 0 1 0

Bien qu'il soit assez tard pour répondre maintenant, il existe un moyen simple de trouver si le Nième bit est défini ou non, en utilisant simplement les opérateurs mathématiques POWER et MODULUS.

Disons que nous voulons savoir si «temp» a un Nième bit défini ou non. L'expression booléenne suivante donnera vrai si le bit est défini, 0 sinon.

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

Prenons l'exemple suivant:

• int temp = 0x5E; // en binaire 0b1011110 // BIT 0 est LSB

Si je veux savoir si le 3ème bit est activé ou non, j'obtiens

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

L'expression renvoie donc vrai, indiquant que le 3ème bit est défini.

Une approche consistera à vérifier dans la condition suivante:

if ( (mask >> bit ) & 1)

Un programme d'explication sera:

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

Production:

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 - Position de bit commençant à 0.

renvoie 0 ou 1.

Je fais ceci:

LATGbits.LATG0 = ((m & 0x8)> 0); // pour vérifier si le bit-2 de m est 1

le moyen le plus rapide semble être une table de recherche pour les masques