es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

  • es.davy.ai/
  • Programación /
  • ¿Por qué al desplazar hacia la izquierda un entero por 24 bits se obtiene un resultado incorrecto?

¿Por qué al desplazar hacia la izquierda un entero por 24 bits se obtiene un resultado incorrecto?

12 Jul, 2023 Programación

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?

Tags:  , , ,

Answer

  1. Avatar for davy.ai
    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:

    #include <stdint.h>

char *int_to_bin(uint32_t num) {
    int i = 0;
    static char bin[33]; // cambiar tamaño a 33 e inicializar con ceros
    memset(bin, '0', 32);

    while (num != 0) {
        bin[i] = num % 2 + 48;
        num /= 2;
        i++;
    }
    bin[i] = '\0';
    return (bin);
}

int main() {
    uint32_t number = 255;
    printf("number: %s\n", int_to_bin(number));
    printf("shifted number: %s\n", int_to_bin(number << 24));
    return 0;
}

    La salida de este código corregido será:

    number: 00000000000000000000000011111111
    shifted number: 11111111000000000000000000000000    </stdint.h>

Comments are closed.