Changement d'un bit d'un entier [dupliquer]

, Vous pouvez régler le quatrième bit d'un nombre par OU-ing avec une valeur qui est nulle partout, sauf dans la quatrième bit. Cela pourrait être fait en tant que

x |= (1u << 3);

de même, vous pouvez effacer le quatrième bit par et-ing avec une valeur qui est un partout sauf dans le quatrième bit. Par exemple:

x &= ~(1u << 3);

enfin, vous pouvez basculer le quatrième bit par XOR-ing avec une valeur qui est nulle partout sauf dans le quatrième bit:

x ^= (1u << 3);

pour voir pourquoi cela fonctionne, nous devons regarder deux choses:

1. Quel est le comportement de l'opérateur << dans ce contexte?
2. Quel est le comportement des opérateurs et, OR, et XOR ici?

dans les trois extraits de code ci-dessus, nous avons utilisé l'opérateur << pour générer une valeur. L'opérateur << est le décalage en Bit-gauche l'opérateur, qui prend une valeur et puis décale tous ses bits d'un certain nombre d'étapes vers la gauche. Dans votre cas, j'ai utilisé

1u << 3

pour prendre la valeur 1 (qui a la représentation binaire 1) et ensuite déplacer tous ses bits sur trois taches, en remplissant les valeurs manquantes avec 0. Cela crée la valeur binaire 1000 , qui a un bit défini dans le quatrième bit.

maintenant, pourquoi

x |= (1u << 3);

placer le quatrième bit de ce nombre? Cela concerne le fonctionnement de L'opérateur de la salle d'opération. L'opérateur |= est comme += ou *= sauf pour bitwise ou-il est équivalent à

x = x | (1u << 3);

alors pourquoi OR-ing x avec la valeur binaire 1000 définit son quatrième bit? Cela a à voir avec la façon dont OU est défini:

0 | 0  == 0
0 | 1  == 1
1 | 0  == 1
1 | 1  == 1

plus important, Cependant, nous pouvons réécrire cela de façon plus compacte comme

x | 0  == x
x | 1  == 1

C'est un fait extrêmement important, car cela signifie QU'OR-ing tout bit avec zéro ne change pas la valeur du bit, alors que OR-ing tout bit avec 1 fixe toujours ce bit à un. Cela signifie que lorsque nous écrivons

x |= (1u << 3);

puisque (1u << 3) est une valeur qui est nulle partout sauf dans le quatrième bit, le bit ou laisse tous les bits de x inchangés sauf pour le quatrième bit, qui est alors mis à un. Plus généralement, ou-un nombre avec une valeur qui est une série de les zéros et les uns préserveront toutes les valeurs où les bits sont zéro et définiront toutes les valeurs où les bits sont un.

maintenant, regardons

x &= ~(1u << 3);

utilise l'opérateur de complément ~ , qui prend un nombre et renverse tous ses bits. Si nous supposons que les entiers sont deux octets (juste pour la simplicité), cela signifie que le codage réel de (1u << 3) est

0000000000001000

quand on prend le complément de cela, nous obtenons le nombre

1111111111110111

maintenant, voyons ce qui se passe quand nous bitwise et deux valeurs ensemble. L'opérateur et a cette intéressante table de vérité:

0 & 0   == 0
0 & 1   == 0
1 & 0   == 0
1 & 1   == 1

ou, plus simplement:

x & 0   == 0
x & 1   == x

notez que cela signifie que si nous et deux nombres ensemble, la valeur résultante sera telle que tous les bits et-ed avec zéro sont mis à zéro, tandis que tous les autres bits sont préserver. Cela signifie que si nous et avec

~(1u << 3)

nous sommes et-ing avec

1111111111110111

donc par notre tableau ci-dessus, cela signifie" garder tous les bits, sauf le quatrième bit, tel quel, et puis changer le quatrième bit pour être zéro."

plus généralement, si vous voulez effacer un ensemble de bits, créez un nombre qui est un partout où vous voulez garder les bits inchangés et zéro où vous voulez effacer les bits.

enfin, voyons pourquoi

x ^= (1u << 3)

renverse le quatrième bit du nombre. C'est parce que l'opérateur XOR binaire a cette table de vérité:

0 ^ 0  == 0
0 ^ 1  == 1
1 ^ 0  == 1
1 ^ 1  == 0

notez que

x ^ 0  == 0
x ^ 1  == ~x

où ~x est le contraire de x; c'est 0 pour 1 et 1 pour 0. Cela signifie que si nous XOR x avec la valeur (1u << 3) , nous sommes XOR - ing avec

0000000000001000

So cela signifie " garder tous les bits sauf le quatrième comme tel, mais retourner le quatrième bit."Plus généralement, si vous voulez retourner un certain nombre de bits, XOR la valeur avec un nombre qui a zéro si vous souhaitez conserver les bits intacte et un autre où vous souhaitez inverser les bits.

Espérons que cette aide!

vous pouvez toujours utiliser std::bitset ce qui rend la modification des bits facile.

ou vous pouvez utiliser des manipulations de bits (en supposant que vous voulez dire 4ème bit Compter à un. Ne soustrayez pas 1 si vous voulez dire compter de 0). Notez que j'utilise 1U juste pour garantir que toute l'opération se passe sur des numéros non signés:

pour définir: x |= (1U << (4 - 1));

à effacer: x &= ~(1U << (4 - 1));

pour basculer: x ^= (1U << (4 - 1));

pour définir le quatrième bit, OR avec 00001000 (binaire).

pour effacer le quatrième bit, AND avec 11110111 (binaire).

pour basculer le quatrième bit, XOR avec 00001000 (binaire).

exemples:

00110010 ou 00001000 = 00111010

00110010 et 11110111 = 00110010

00110010 XOR 00001000 = 00111010

Simple, puisque vous avez, ou n'importe quelle valeur que vous avez,

int x = 50;

pour programmer le 4ème bit (de droite),

int y = x | 0x00000008;

parce que, 0x préfixé avant un nombre signifie qu'il est de forme hexadécimale. Donc, 0x0 = 0000 en binaire, et 0x8=1000 en binaire. Ça explique la réponse.

essayez l'une de ces fonctions en langage C pour changer de bit

char bitfield;

// start at 0th position

void chang_n_bit(int n, int value)
{
    bitfield = (bitfield | (1 << n)) & (~( (1 << n) ^ (value << n) ));
}

void chang_n_bit(int n, int value)
{
    bitfield = (bitfield | (1 << n)) & ((value << n) | ((~0) ^ (1 << n)));
}

void chang_n_bit(int n, int value)
{
    if(value)
        bitfield |= 1 << n;
    else
        bitfield &= ~0 ^ (1 << n);
}

char print_n_bit(int n)
{
    return (bitfield & (1 << n)) ? 1 : 0;
}

vous pouvez utiliser binaire et / ou basculer le quatrième bit.

pour régler le quatrième bit sur x, vous utiliserez x |= 1<<3; , 1<<3 étant un décalage à gauche de 0b0001 par trois bits produisant 0b1000.

pour effacer le quatrième bit sur x, vous utiliserez x &= ~(1<<3); , un binaire et entre 0b00110010 (x) et (effectivement) 0b11110111, masquant chaque bit dans x qui n'est pas en position quatre, l'effaçant ainsi.