Difficulty in placing non-significant zeros in a converted binary number

Question

Difficulty in placing non-significant zeros in a converted binary number

Navigation

#1 by (4 votes)

4

I found a code on the web that converts decimals to binaries (32 bits), however I needed one of (256 bits) so I changed the code the way I thought it was correct, however after a certain size the non-significant zeros are added 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 limit of correct zeros, in the code would be i = 67 ...

HereistheexecutionIneeded...However,asyoucansee,withi>67(255,inthiscase)a"1" does not make sense ...

What's wrong with the code?

c

asked by anonymous 27.11.2016 / 23:55

1 answer

Incomplete Edge Package bRasilLegis [command "getDetailsDownload"]

score 4 · Accepted Answer

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

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

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

#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] = 'Numero convertido para 256 com os 0 nao significativos:
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
000000000000000011111111111111110001111100011111010001100110000


Numero convertido: 140735601943344

11111111111111110001111100011111010001100110000
Pressione qualquer tecla para continuar. . .
'; // "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):

#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] = 'Numero convertido para 256 com os 0 nao significativos:
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
000000000000000011111111111111110001111100011111010001100110000


Numero convertido: 140735601943344

11111111111111110001111100011111010001100110000
Pressione qualquer tecla para continuar. . .
'; // "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;
}

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 shift operator performs much better.