Comment régler, effacer et basculer un seul bit ?

Question

Comment régler, effacer et basculer un bit ?

Answer 1

Réglage d'un bit

Utilisez l'opérateur OU par bit ( | ) pour définir un bit.

number |= 1UL << n;

Cela fixera le n ème partie de number . n doit être égal à zéro, si vous souhaitez définir l'option 1 et ainsi de suite jusqu'à n-1 si vous voulez régler le n ement.

Utilice 1ULL si number est plus large que unsigned long ; la promotion de 1UL << n ne se produit qu'après avoir évalué 1UL << n où le comportement non défini consiste à décaler de plus de la largeur d'un long . Il en va de même pour tous les autres exemples.

Dégager un peu

Utilisez l'opérateur ET binaire ( & ) pour effacer un bit.

number &= ~(1UL << n);

Cela permettra d'effacer les n ème partie de number . Vous devez inverser la chaîne de bits avec l'opérateur bitwise NOT ( ~ ), puis ET.

Basculer un peu

L'opérateur XOR ( ^ ) peut être utilisé pour basculer un bit.

number ^= 1UL << n;

Cela fera basculer le n ème partie de number .

Vérifier un peu

Tu n'as pas demandé ça, mais je pourrais tout aussi bien l'ajouter.

Pour vérifier un bit, décalez le nombre n vers la droite, puis effectuez un ET bit à bit :

bit = (number >> n) & 1U;

Cela mettra la valeur de la n ème partie de number dans la variable bit .

Changer le n e bit à x

Définir le n e bit à l'un ou l'autre 1 o 0 peut être réalisé avec ce qui suit sur une implémentation C++ à complément à 2 :

number ^= (-x ^ number) & (1UL << n);

Bit n sera définie si x es 1 et effacé si x es 0 . Si x a une autre valeur, vous obtenez des déchets. x = !!x le rendra booléen à 0 ou 1.

Pour que cela soit indépendant du comportement de négation du complément à 2 (où -1 a tous les bits définis, contrairement à une implémentation C++ de complément à 1 ou de signe/magnitude), utilisez la négation non signée.

number ^= (-(unsigned long)x ^ number) & (1UL << n);

o

unsigned long newbit = !!x;    // Also booleanize to force 0 or 1
number ^= (-newbit ^ number) & (1UL << n);

C'est généralement une bonne idée d'utiliser des types non signés pour la manipulation portable des bits.

o

number = (number & ~(1UL << n)) | (x << n);

(number & ~(1UL << n)) effacera le n e bit et (x << n) définira le n e bit à x .

C'est aussi une bonne idée de ne pas copier/coller le code en général et beaucoup de gens utilisent des macros de préprocesseur (telles que la réponse du wiki communautaire plus bas ) ou une sorte d'encapsulation.

Answer 2

Utilisation de la bibliothèque standard C++ : std::bitset<N> .

Ou le Boost version : boost::dynamic_bitset .

Il n'est pas nécessaire d'en faire un :

#include <bitset>
#include <iostream>

int main()
{
    std::bitset<5> x;

    x[1] = 1;
    x[2] = 0;
    // Note x[0-4]  valid

    std::cout << x << std::endl;
}

---

[Alpha:] > ./a.out
00010

La version Boost permet un jeu de bits de taille d'exécution par rapport à un bibliothèque standard un jeu de bits dimensionné au moment de la compilation.

Answer 3

L'autre option consiste à utiliser des champs de bits :

struct bits {
    unsigned int a:1;
    unsigned int b:1;
    unsigned int c:1;
};

struct bits mybits;

définit un champ de 3 bits (en fait, il s'agit de trois champs de 1 bit). Les opérations sur les bits sont maintenant un peu (haha) plus simples :

Pour activer ou désactiver un bit :

mybits.b = 1;
mybits.c = 0;

Pour basculer un peu :

mybits.a = !mybits.a;
mybits.b = ~mybits.b;
mybits.c ^= 1;  /* all work */

Je vérifie un peu :

if (mybits.c)  //if mybits.c is non zero the next line below will execute

Cela ne fonctionne qu'avec des champs de bits de taille fixe. Sinon, vous devez recourir aux techniques de manipulation des bits décrites dans les messages précédents.

Answer 4

J'utilise des macros définies dans un fichier d'en-tête pour gérer l'activation et la désactivation des bits :

/* a=target variable, b=bit number to act upon 0-n */
#define BIT_SET(a,b) ((a) |= (1ULL<<(b)))
#define BIT_CLEAR(a,b) ((a) &= ~(1ULL<<(b)))
#define BIT_FLIP(a,b) ((a) ^= (1ULL<<(b)))
#define BIT_CHECK(a,b) (!!((a) & (1ULL<<(b))))        // '!!' to make sure this returns 0 or 1

/* x=target variable, y=mask */
#define BITMASK_SET(x,y) ((x) |= (y))
#define BITMASK_CLEAR(x,y) ((x) &= (~(y)))
#define BITMASK_FLIP(x,y) ((x) ^= (y))
#define BITMASK_CHECK_ALL(x,y) (!(~(x) & (y)))
#define BITMASK_CHECK_ANY(x,y) ((x) & (y))

Answer 5

Il est parfois utile d'utiliser un enum a nom les bits :

enum ThingFlags = {
  ThingMask  = 0x0000,
  ThingFlag0 = 1 << 0,
  ThingFlag1 = 1 << 1,
  ThingError = 1 << 8,
}

Utilisez ensuite le noms plus tard. Par exemple, écrivez

thingstate |= ThingFlag1;
thingstate &= ~ThingFlag0;
if (thing & ThingError) {...}

pour définir, effacer et tester. De cette façon, vous cachez les chiffres magiques du reste de votre code.

Sinon, j'approuve la solution de Jeremy.