C / C ++ vérifie si un bit est activé, c'est-à-dire variable int

Question

 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 et masquage de bit.

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

Answer 1

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

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

et l'utiliser de cette façon:

 CHECK_BIT(temp, 3)
 

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

Answer 2

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.

Answer 3

Je voudrais juste utiliser un std :: bits si c'est C ++. Simple. 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 bêtise

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

Answer 4

Oui, je sais, je n'ai pas "avoir" à faire de cette façon. Mais j'ai l'habitude d'écrire:

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

E. g.:

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

Entre autres choses, cette approche:

• Accueille 8/16/32/64 bits entiers.
• Détecte IsBitSet(int32,int64) appelle à mon insu et consentement.
• Inline Modèle, donc pas d'appel de fonction frais généraux.
• const& références, donc rien de besoins pour être dupliqué, copié. Et nous sommes assurés que le compilateur va ramasser toutes les typo que de tenter de modifier les arguments.
• 0!= rend le code plus clair et évident. Le principal point à l'écriture de code est toujours à communiquer clairement et efficacement avec les autres programmeurs, y compris ceux de moindre compétence.
• Tout n'est pas applicable à ce cas particulier... En général, basées sur des modèles de fonctions d'éviter la question de l'évaluation des arguments à plusieurs reprises. Un problème connu avec certains #définir des macros.
  E. g.: #define ABS(X) (((X)<0) ? - (X) : (X))
  ABS(i++);

Answer 5

Selon cette description de bit-champs, il y a une méthode pour définir et d'accéder à des champs directement. 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)
    /* ... */

Aussi, il y a un avertissement:

Cependant, peu de membres dans les structures d'avoir des inconvénients. Premièrement, l'ordre des bits dans la mémoire est dépendants de l'architecture et de la mémoire rembourrage règles varie d'un compilateur de compilateur. En outre, de nombreux populaire, les compilateurs génèrent inefficace code pour la lecture et l'écriture de peu de membres, et il y a potentiellement grave pour la sécurité des threads questions relatives aux champs de bits (en particulier sur les systèmes multiprocesseurs) en raison du fait que la plupart des machines ne peut pas manipuler arbitraire des ensembles de bits dans la mémoire, mais plutôt charger et stocker des mots entiers.