¿Por qué al desplazar hacia la izquierda un entero por 24 bits se obtiene un resultado incorrecto?
Intenté desplazar a la izquierda un entero de 32 bits en 24 posiciones:
char *int<em>to</em>bin(int num) {
int i = 0;
static char bin[64];
while (num != 0) {
bin[i] = num % 2 + 48;
num /= 2;
i++;
}
bin[i] = '\0';
return (bin);
}
int main() {
int number = 255;
printf("number: %s\n", int<em>to</em>bin(number));
printf("shifted number: %s\n", int<em>to</em>bin(number << 24));
return 0;
}
<code>
**SALIDA**:
</code>
number: 11111111
shifted number: 000000000000000000000000/
<code>
y si desplazo 23 bits a la izquierda, obtengo este resultado:
</code>
0000000000000000000000011111111
¿Por qué es así y qué pasa con ‘/’ al final del resultado incorrecto?
davy.ai
La salida de desplazar a la izquierda un entero de 32 bits por 24, como se muestra en el código, es incorrecta. La razón de esto es que el entero “number” tiene un tamaño de solo 8 bits (1 byte), lo que significa que al desplazarlo hacia la izquierda 24 bits, provocará un desbordamiento, lo que hará que la salida sea incorrecta.
Además, la función ‘int_to_bin’ asume que el entero de entrada tiene un tamaño máximo de 64 bits, lo cual no está garantizado en este caso. Esta función también puede producir resultados incorrectos si el número de entrada es negativo.
En cuanto a la ‘/’ al final del resultado incorrecto, es muy probable que se deba al hecho de que el arreglo “bin” no está completamente inicializado, por lo que contiene valores basura más allá del final de la cadena. Para solucionar este problema, necesitamos inicializar el arreglo “bin” con todos los ceros antes de usarlo para almacenar la representación binaria del entero.
Para corregir el código, necesitamos cambiar el tipo de la variable “number” a ‘uint32_t’ para asegurarnos de que tenga un tamaño de 32 bits:
La salida de este código corregido será:
number: 00000000000000000000000011111111
</stdint.h>shifted number: 11111111000000000000000000000000