que - javascript 0xff
¿Qué hace AND 0xFF? (7)
Al hacer un número entero con 0xFF
solo queda el byte menos significativo. Por ejemplo, para obtener el primer byte en un short s
, puede escribir s & 0xFF
. Esto se conoce como "enmascaramiento". Si byte1
es un tipo de byte único (como uint8_t
) o ya es menor que 256 (y como resultado es todo ceros, excepto el byte menos significativo), no hay necesidad de enmascarar los bits más altos, ya que son cero.
Consulte la respuesta de tristopia Patrick Schlüter a continuación cuando puede estar trabajando con tipos firmados. Al realizar operaciones en modo bit, recomiendo trabajar solo con tipos sin signo.
En el siguiente código:
short = ((byte2 << 8) | (byte1 & 0xFF))
¿Cuál es el propósito de &0xFF
? Porque otros somestimes lo veo escrito como:
short = ((byte2 << 8) | byte1)
Y eso parece funcionar bien también?
El peligro de la segunda expresión viene si el tipo de byte1
es char
. En ese caso, algunas implementaciones pueden tener signed char
, lo que dará como resultado la extensión de la señal al evaluar.
signed char byte1 = 0x80;
signed char byte2 = 0x10;
unsigned short value1 = ((byte2 << 8) | (byte1 & 0xFF));
unsigned short value2 = ((byte2 << 8) | byte1);
printf("value1=%hu %hx/n", value1, value1);
printf("value2=%hu %hx/n", value2, value2);
imprimirá
value1=4224 1080 right
value2=65408 ff80 wrong!!
Lo probé en gcc v3.4.6 en Solaris SPARC 64 bit y el resultado es el mismo con byte1
y byte2
declarados como char
.
TL; DR
El enmascaramiento es para evitar la extensión de signo implícita.
EDITAR : Comprobé, es el mismo comportamiento en C ++.
Suponiendo que tu byte1
es un byte (8bits), cuando haces un AND a nivel de bit de un byte con 0xFF, obtienes el mismo byte.
Entonces byte1
es lo mismo que byte1 & 0xFF
Say byte1
es 01001101
, luego byte1 & 0xFF = 01001101 & 11111111 = 01001101 = byte1
Si byte1 es de algún otro tipo, digamos un entero de 4 bytes, Y a nivel de bit Y con 0xFF lo deja con el byte menos significativo (8 bits) del byte1.
borra todos los bits que no están en el primer byte
si byte1
es un tipo entero de 8 bits, no tiene sentido; si es más de 8 bits, esencialmente le dará los últimos 8 bits del valor:
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
& 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
-------------------------------
0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1
& 0xFF
solo asegura que si los bytes son más largos que 8 bits (permitido por el estándar de idioma), el resto se ignoran.
Y eso parece funcionar bien también?
Si el resultado es mayor que SHRT_MAX
, obtienes un comportamiento indefinido. En ese sentido, ambos funcionarán igual de mal.
byte1 & 0xff
asegura que solo los 8 bits menos significativos de byte1
pueden ser distintos de cero.
si byte1
ya es un tipo sin signo que tiene solo 8 bits (por ejemplo, char
en algunos casos, o unsigned char
en la mayoría), no hará ninguna diferencia / es completamente innecesario.
Si byte1
es un tipo que está firmado o tiene más de 8 bits (por ejemplo, short
, int
, long
), y cualquiera de los bits, excepto el 8 least significant, se establecerá una diferencia (es decir, se pondrán a cero esos bits superiores antes or
con la otra variable, por lo que este operando de or
afecta solo a los 8 bits menos significativos del resultado).