No soy tan bueno con los operadores bit a bit así que disculpe la pregunta, pero ¿cómo borraría los 16 bits inferiores de un entero de 32 bits en C/C++?Claro inferior 16 bits
Por ejemplo, tengo un entero: 0x12345678 y yo quiero hacer lo siguiente: 0x12340000
Para despejar cualquier conjunto de bits, puede utilizar AND bit a bit con el complemento de un número que tiene 1s en esos lugares. En su caso, ya que el número 0xFFFF ha fijado sus 16 bits más bajos, se puede y con su complemento:
b &= ~0xFFFF; // Clear lower 16 bits.
Si quería establece esos bits, se podría utilizar en su lugar un OR con un número que ha establecido esos bits:
b |= 0xFFFF; // Set lower 16 bits.
Y, si se quería flip esos bits, se puede utilizar un XOR bit a bit con un número que tiene los bits establecidos:
b ^= 0xFFFF; // Flip lower 16 bits.
Espero que esto ayude!
Una forma sería a nivel de bit Y con 0xFFFF0000 p. Ej. value = value & 0xFFFF0000
Utilice un y (&) con una máscara que se hace de los mejores 16 bits todos unos (que dejará a los bits superiores como son) y los bits inferiores todos los ceros (que matará a los bits inferiores del número).
Así que será
0x12345678 & 0xffff0000
Si el tamaño del tipo no se conoce y que desea enmascarar sólo los 16 bits más bajos también se puede construir la máscara de otra manera: usar una máscara eso sería dejar pasar sólo los 16 bits más bajos
0xffff
e invertir con el bit a bit no (~), por lo que se convertirá en una máscara que mata sólo los 16 bits más bajos:
0x12345678 & ~0xffff
int x = 0x12345678;
int mask = 0xffff0000;
x &= mask;
Para tomar otro camino puede probar
x = ((x >> 16) << 16);
Suponiendo que el valor que desea borrar los bits de tiene un tipo sin signo no de "pequeño rango", esta es la manera portátil más segura, para borrar los 16 bits más bajos:
b &= -0x10000;
el valor -0x10000 será promovido con el tipo de b (un tipo sin signo) por la aritmética modular, lo que resulta en todo se establecen altos bits y los 16 bits bajos son cero.
Editar: En realidad la respuesta de James es el más seguro (casos de uso más amplio) de todo, pero la forma en que su respuesta y la mía se generalizan a otros problemas similares es un poco diferente y mina puede ser más aplicable en los problemas relacionados.
¿Por qué no hacer algo como 'b & = ~ (1? 0xFFFF: b);'? –
Esto es realmente bueno porque también funciona con valores de 16 y 64 bits, si no me equivoco. –
@Ray: ¿por qué no? – James
@ James- Si intenta hacer algo como 'b & 0xFFFF0000' en una máquina que no sea de 32 bits (por ejemplo, una máquina de 64 bits), entonces esto podría terminar borrando accidentalmente los 32 bits más altos además de los 32 bits bajos. bits. – templatetypedef