Difficulty placing non-significant zeros in a converted binary number

Question

I found a code on the web that converts decimals to binaries (32 bits), but I needed one (256 bits) so I changed the code in the way I thought was correct, but after the given size the nonsignificant zeros are added in the correct way...

int main() {
    unsigned long long int n = 140735601943344; // Número de entrada
    unsigned long long int r; // Resultado do deslocamento
    int i; // Contador

    // Lê o número
    //printf("Digite o numero: ");
    //scanf("%llu", &n);

    printf("\nNumero convertido para 256 com os 0 nao significativos:\n");
    // Utiliza um número de 256 bits como base para a conversão.
    for(i = 255; i >= 0; i--) {
    // Executa a operação shift right até a 
    // última posição da direita para cada bit.
        r = n >> i;

    // Por meio do "e" lógico ele compara se o valor 
    // na posição mais à direita é 1 ou 0 
    // e imprime na tela até reproduzir o número binário.
        if(r & 1) {
            printf("1");
        } else {
            printf("0");
        }
    } 
    printf("\n");
    printf("\nNumero convertido: 140735601943344\n");
    printf("\n11111111111111110001111100011111010001100110000\n");

    system("pause");
    return 0;
}

In this image is the correct zeros limit, in the code i = 67...

Here is the execution I needed... However, as you can see, with i > 67 (255, in this case) there is a "1" that makes no sense...

What’s wrong with the code?

Answer 1

The operator shift has a cap that depends on the platform/compiler.

If you are using the gcc on a 64-bit PC platform, for example, and exceeding 64 the behavior of that operator is undefined.

A possible (and simple) solution for the 64-bit conversion case is to create a buffer to store the result and divide the number by 2 successively to obtain the bits. When the division reaches zero, the next divisions will always return the zero bit:

#include <stdio.h>
#include <stdlib.h>

int main()
{

  unsigned long long int n = 140735601943344; // Número de entrada
  char buffer[257]; // Buffer para armazenar o resultado
  int i; // Contador

  buffer[256] = '\0'; // "zera" o último caracter do buffer
  printf("\nNumero convertido para 256 com os 0 nao significativos:\n");

  // Utiliza um número de 256 bits como base para a conversão.
  for(i = 255; i >= 0; i--)
  {
    // Por meio do "e" lógico ele compara se o valor 
    // na posição mais à direita é 1 ou 0 
    // e guarda o dígito binário no buffer.
    if(n & 1)
    {
      buffer[i] = '1';
    } else {
      buffer[i] = '0';
    }
    // Divide o número por 2 para obter o próximo bit
    n /= 2; 
  }
  printf("%s\n", buffer);
  printf("\n");
  printf("\nNumero convertido: 140735601943344\n");
  printf("\n11111111111111110001111100011111010001100110000\n");

  system("pause");
  return 0;
}

After execution (truncated, for easy viewing):

Numero convertido para 256 com os 0 nao significativos:
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
000000000000000011111111111111110001111100011111010001100110000


Numero convertido: 140735601943344

11111111111111110001111100011111010001100110000
Pressione qualquer tecla para continuar. . .

There are other ways to do this implementation and, if the operator does not exceed the bit width of the data, the version with the operator shift has a much better performance.