C Converter inteiros em binarios

[Jessé P. de Melo]

Boa noite.

 

Sou novo na programação C. Essa é a primeira vez que estou realizando manipulação de ponteiros e memoria dinâmica. 

Este é um exercício que pediu para converter um numero inteiro para números binários. Segue o código comentado:

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

void main (void){

int binario (int x); // Prototipo função

int v1=522; // valor decimal

printf("O numero %i em binario e' %s",v1,binario(v1)); // chamo a função que realiza conversão.

}

int binario (int x){
    int r; // Variavel para retorno de inteiro
    char *p; // ponteiro para char
    *p=0; //inicializando ponteiro para lugar nenhum
    int count=0;// variavel para memoria dinamica

    while(x<0){ // Só faz algo se o valor for maior que 0

        if ((x%2)>0){ //Se a divisão por 2 tiver resto
            x=x%2; //Atribui o resto ao valor de x
            count++;
            p=(int*)malloc(count*sizeof(char)); //Aloca memoria de acordo com a necessidade
            p[count-1] = '1'; // A contagem começou antes de usar posição 0 do vetor/ponteiro , então coloco -1 uma posição atrás
            }

        else{ //Se a divisão por 2 não tiver resto
            count++;
            p=(int*)malloc(count*sizeof(char));//Aloca memoria de acordo com a necessidade
            p[count-1] = '0';
            }
        }
        p[count+1]='\0'; //coloco '\0' para finalizar a string
        r=atoi(*p); // converto o valor da string para inteiro para imprimir
        free(p); //libero a memoria do ponteiro.
        return(r); //retorno o valor inteiro
}

 

[isrnick]

Eu faço assim:

#include <stdio.h>

unsigned long long binario(long n){
    unsigned long long r = 0, m;
    
    for(m = 1; n > 0; m *= 10){
        r = r + n % 2 * m;
        n = n/2;
    }
    return r;
}

int main()
{
    printf("%7ld -> %020llu\n", 1048575, binario(1048575));
    printf("%7ld -> %020llu\n", 1, binario(1));
    printf("%7ld -> %020llu\n", 2, binario(2));
    printf("%7ld -> %020llu\n", 3, binario(3));
    printf("%7ld -> %020llu\n", 4, binario(4));
    printf("%7ld -> %020llu\n", 5, binario(5));
    printf("%7ld -> %020llu\n", 6, binario(6));
    printf("%7ld -> %020llu\n", 7, binario(7));
    printf("%7ld -> %020llu\n", 8, binario(8));
    printf("%7ld -> %020llu\n", 9, binario(9));
    printf("%7ld -> %020llu\n", 255, binario(255));
    
    return 0;
}

 

[Jessé P. de Melo]

Não entendi  o que aconteceu ! Poderia explicar?

[isrnick]

Eu dei uma explicação disso em outro tópico a alguns anos e acho que pode servir pra você:

Em 12/03/2015 às 20:18, isrnick disse:

Vamos usar seu exemplo:

 

11 % 2 = 1

11 / 2 = 5

 

5 % 2 = 1

5 / 2 = 2

 

2 % 2 = 0

2 / 2 = 1

 

1 % 2 = 1

1 / 2 = 0

 

Se você imprimir logo após calcular o resto, ele vai imprimir os dígitos no prompt primeiro 1, depois 1, depois 0 e por fim 1, ou seja sai o número binário ao contrário, que não é o que desejamos.

 

 

O que precisamos é colocar os dígitos no casa/sequência certa... Mas como fazer isso?

 

Uma possibilidade seria gerar uma número inteiro que represente o número binário desejado e imprimi-lo, neste exemplo o número seria 1011 (mil e onze), que é representação do número decimal 11 em binário. Então vamos ver as casas do número desejado neste exemplo:

casas  4 3 2 1
       | | | |
número 1 0 1 1

Queremos que o primeiro dígito fique na casa 1, que é a casa das unidades. Que o segundo dígito fique na casa 2, ou seja na casa das dezenas. Que o terceiro fique na casa 3, a casa das centenas, e assim por diante...

 

Então seja Dn o enésimo dígito binário, logo temos que:

 

Número inteiro que representa um número binário (com 4 dígitos) = D4 * 1000 + D3 * 100 + D2 * 10 + D1 * 1

= D4 * 10 * 10 * 10 + D3 * 10 * 10 + D2 * 10 + D1 * 1

= D4 * 10³ + D3 * 10² + D2 * 10¹ + D1 * 10⁰

( Generalizando: Representação = {SOMATÓRIA ₁ ⁿ } [ Dn * 10 ^(n-1) ] )

 

Então apenas deslocamos cada novo dígito calculado para a esquerda em uma casa aumentando o multiplicador em uma ordem de magnitude (= x10) a cada execução do ciclo, e então somamos aos anteriores, para obter a representação do número binário.

 

Tópico original: 

 

 

[Jessé P. de Melo]

Muito boa explicação. 

[isrnick]

Lembrei de outra interessante que vi no fórum postado por alguém, mas não lembro quem...

 

Essa função recursiva apenas imprime na tela o número binário, mas não retorna o número binário para ser usado por outra parte do programa. Mas tem a vantagem de conseguir "converter" e imprimir números muito maiores.

 

#include <stdio.h>

void imprimebinario(unsigned long long n){
    if(n > 0) {
        imprimebinario(n / 2);
        printf("%d", (int)(n % 2));
    }
}

int main()
{
    printf("%ld -> ", 1048575);
    imprimebinario(1048575);
    printf("\n");
    
    printf("%d -> ", 9);
    imprimebinario(9);
    printf("\n");
    
    printf("%d -> ", 10);
    imprimebinario(10);
    printf("\n");
    
    printf("%d -> ", 11);
    imprimebinario(11);
    printf("\n");

    printf("%llu -> ", 18446744073709551615);
    imprimebinario(18446744073709551615);
    printf("\n");
    
    return 0;
}