que - javascript 0xff

¿Qué hace AND 0xFF?

Question

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?

Answer 1

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.

Answer 2

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 ++.

Answer 3

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.

Answer 4

borra todos los bits que no están en el primer byte

Answer 5

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

Answer 6

& 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.

Answer 7

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).