parse - stoi c++

Cambiar un bit de un entero

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo configura, borra y alterna un solo bit? 26 respuestas

Tenemos un numero entero

int x = 50;

en binario, es

00110010

¿Cómo puedo cambiar programáticamente el cuarto (4to) bit?

Answer 1

Para establecer el cuarto bit, OR con 00001000 (binario).

Para borrar el cuarto bit, AND con 11110111 (binario).

Para alternar el cuarto bit, XOR con 00001000 (binario).

Ejemplos:

00110010 o 00001000 = 00111010

00110010 Y 11110111 = 00110010

00110010 XOR 00001000 = 00111010

Answer 2

Pruebe una de estas funciones en lenguaje C para cambiar n bits

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

Answer 3

Puede configurar el cuarto bit de un número OR-ingiriéndolo con un valor que sea cero en todas partes excepto en el cuarto bit. Esto podría hacerse como

x |= (1u << 3);

De manera similar, puede borrar el cuarto bit YY con un valor que sea uno en todas partes excepto en el cuarto bit. Por ejemplo:

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

Finalmente, puede alternar el cuarto bit por XOR, ingiriéndolo con un valor que sea cero en todas partes, excepto en el cuarto bit:

x ^= (1u << 3);

Para ver por qué esto funciona, necesitamos ver dos cosas:

1. ¿Cuál es el comportamiento del operador << en este contexto?
2. ¿Cuál es el comportamiento de los operadores AND, OR y XOR aquí?

En los tres fragmentos de código anteriores, usamos el operador << para generar un valor. El operador << es el operador de desplazamiento a la izquierda a nivel de bits, que toma un valor y luego desplaza todos sus bits un cierto número de pasos hacia la izquierda. En tu caso, utilicé.

1u << 3

para tomar el valor 1 (que tiene una representación binaria 1) y luego desplazar todos sus bits en tres puntos, completando los valores faltantes con 0. Esto crea el valor binario 1000 , que tiene un bit establecido en el cuarto bit.

Ahora por que

x |= (1u << 3);

establecer el cuarto bit del número? Esto tiene que ver con cómo funciona el operador OR. El operador |= es como += o *= excepto bitwise OR - es equivalente a

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

Entonces, ¿por qué OR-ing x con el valor binario 1000 establece su cuarto bit? Esto tiene que ver con la forma en que se define OR:

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

Sin embargo, lo más importante es que podemos reescribir esto de manera más compacta como

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

Este es un hecho extremadamente importante, porque significa que OR-ing cualquier bit con cero no cambia el valor del bit, mientras que OR-ing cualquier bit con 1 siempre establece ese bit en uno. Esto significa que cuando escribimos

x |= (1u << 3);

ya que (1u << 3) es un valor que es cero en todas partes excepto en el cuarto bit, el bit a bit OR deja sin cambios a todos los bits de x, excepto al cuarto bit, que luego se establece en uno. Más generalmente, OR-ing un número con un valor que es una serie de ceros y unos conservará todos los valores donde los bits son cero y establecerá todos los valores donde los bits son uno.

Ahora, veamos

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

Esto utiliza el operador de complemento a nivel de bits ~ , que toma un número y voltea todos sus bits. Si asumimos que los enteros son dos bytes (solo por simplicidad), esto significa que la codificación real de (1u << 3) es

0000000000001000

Cuando tomamos el complemento de esto, obtenemos el número.

1111111111110111

Ahora, veamos qué sucede cuando hacemos bit y dos valores juntos. El operador AND tiene esta interesante tabla de verdad:

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

O, de forma más compacta:

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

Observe que esto significa que si nosotros Y dos números juntos, el valor resultante será tal que todos los bits AND-ed con cero se ajusten a cero, mientras que todos los otros bits se conservan. Esto significa que si nosotros y con

~(1u << 3)

estamos yendo con

1111111111110111

Por lo tanto, según nuestra tabla anterior, esto significa "mantener todos los bits, excepto el cuarto bit, tal como está, y luego cambiar el cuarto bit a cero".

Más generalmente, si desea borrar un conjunto de bits, cree un número que sea uno en todos los lugares donde desee mantener los bits sin cambios y cero en el lugar en el que desee borrar los bits.

Finalmente, veamos por qué

x ^= (1u << 3)

Voltea el cuarto bit del número. Esto se debe a que el operador binario XOR tiene esta tabla de verdad:

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

Darse cuenta de

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

Donde ~x es el opuesto de x; es 0 para 1 y 1 para 0. Esto significa que si XOR x con el valor (1u << 3) , estamos XOR-ing con

0000000000001000

Así que esto significa "mantener todos los bits, pero el cuarto bit establecido como está, pero voltear el cuarto bit". De manera más general, si desea invertir algún número de bits, XOR el valor con un número que tiene cero en el que desea mantener los bits intactos y uno en el que desea invertir estos bits.

¡Espero que esto ayude!

Answer 4

Puede usar el binario AND y OR para alternar el cuarto bit.

Para establecer el cuarto bit en x, usaría x |= 1<<3; , 1<<3 es un desplazamiento a la izquierda de 0b0001 por tres bits que producen 0b1000.

Para borrar el cuarto bit en x, usaría x &= ~(1<<3); , un binario Y entre 0b00110010 (x) y (efectivamente) 0b11110111, enmascarando cada bit en x que no está en la posición cuatro, por lo que se borra.

Answer 5

Siempre se puede usar std::bitset que facilita la modificación de bits.

O puede usar manipulaciones de bits (suponiendo que se refiere al conteo de 4 bits en uno. No reste 1 si quiere decir que cuenta a partir de 0). Tenga en cuenta que uso 1U solo para garantizar que toda la operación se realice en números sin firma:

Para configurar: x |= (1U << (4 - 1));

Para borrar: x &= ~(1U << (4 - 1));

Para alternar: x ^= (1U << (4 - 1));

Answer 6

Simple, ya que tienes, o cualquier valor que tenga,

int x = 50;

Para configurar 4to bit (desde la derecha) programáticamente,

int y = x | 0x00000008;

Porque, 0x prefijado antes de un número significa que es forma hexadecimal. Entonces, 0x0 = 0000 en binario, y 0x8=1000 en forma binaria. Eso explica la respuesta.