Mostrar la representación binaria de un número en C? [duplicar]

Question

  

Duplicar posible:
   ¿Existe un convertidor printf para imprimir en formato binario

Aprendiendo C y me preguntaba:

Dado un número, es posible hacer algo como lo siguiente?

char a = 5;
printf("binary representation of a = %b",a);
> 101

O tendría que escribir mi propio método para hacer la transformación a binario?

Answer 1

Si (escribir su propia), algo así como la siguiente función completa.

#include <stdio.h> /* only needed for the printf() in main(). */
#include <string.h>

/* Create a string of binary digits based on the input value.
   Input:
       val:  value to convert.
       buff: buffer to write to must be >= sz+1 chars.
       sz:   size of buffer.
   Returns address of string or NULL if not enough space provided.
*/
static char *binrep (unsigned int val, char *buff, int sz) {
    char *pbuff = buff;

    /* Must be able to store one character at least. */
    if (sz < 1) return NULL;

    /* Special case for zero to ensure some output. */
    if (val == 0) {
        *pbuff++ = '0';
        *pbuff = '\0';
        return buff;
    }

    /* Work from the end of the buffer back. */
    pbuff += sz;
    *pbuff-- = '\0';

    /* For each bit (going backwards) store character. */
    while (val != 0) {
        if (sz-- == 0) return NULL;
        *pbuff-- = ((val & 1) == 1) ? '1' : '0';

        /* Get next bit. */
        val >>= 1;
    }
    return pbuff+1;
}

Añadir este principal al final de la misma para verlo en funcionamiento:

#define SZ 32
int main(int argc, char *argv[]) {
    int i;
    int n;
    char buff[SZ+1];

    /* Process all arguments, outputting their binary. */
    for (i = 1; i < argc; i++) {
        n = atoi (argv[i]);
        printf("[%3d] %9d -> %s (from '%s')\n", i, n,
            binrep(n,buff,SZ), argv[i]);
    }

    return 0;
}

Ejecutar con "progname 0 7 12 52 123" para obtener:

[  1]         0 -> 0 (from '0')
[  2]         7 -> 111 (from '7')
[  3]        12 -> 1100 (from '12')
[  4]        52 -> 110100 (from '52')
[  5]       123 -> 1111011 (from '123')

Answer 2

No hay forma directa (es decir, usando printf u otra función de biblioteca estándar) para imprimirlo. Usted tendrá que escribir su propia función.

/* This code has an obvious bug and another non-obvious one :) */
void printbits(unsigned char v) {
   for (; v; v >>= 1) putchar('0' + (v & 1));
}

Si está utilizando el terminal, puede utilizar los códigos de control para imprimir bytes de orden natural:

void printbits(unsigned char v) {
    printf("%*s", (int)ceil(log2(v)) + 1, ""); 
    for (; v; v >>= 1) printf("\x1b[2D%c",'0' + (v & 1));
}

Answer 3

Sobre la base de la respuesta de dirkgently , pero la fijación de sus dos errores, y siempre la impresión de un número fijo de dígitos:

void printbits(unsigned char v) {
  int i; // for C89 compatability
  for(i = 7; i >= 0; i--) putchar('0' + ((v >> i) & 1));
}

Answer 4

#include<iostream>
#include<conio.h>
#include<stdlib.h>
using namespace std;
void displayBinary(int n)
{
       char bistr[1000];
       itoa(n,bistr,2);       //2 means binary u can convert n upto base 36
       printf("%s",bistr);

}

int main()
{
    int n;
    cin>>n;
    displayBinary(n);
    getch();
    return 0;
}

Answer 5

Utilice una tabla de búsqueda, como:

char *table[16] = {"0000", "0001", .... "1111"};

a continuación, imprimir cada cuarteto como esto

printf("%s%s", table[a / 0x10], table[a % 0x10]);

Sin duda, se puede usar una sola mesa, pero será ligeramente más rápido y demasiado grande.

Answer 6

Este código debe manejar sus necesidades de hasta 64 bits.

char* pBinFill(long int x,char *so, char fillChar); // version with fill
char* pBin(long int x, char *so);                    // version without fill
#define width 64

char* pBin(long int x,char *so)
{
 char s[width+1];
 int    i=width;
 s[i--]=0x00;   // terminate string
 do
 { // fill in array from right to left
  s[i--]=(x & 1) ? '1':'0';  // determine bit
  x>>=1;  // shift right 1 bit
 } while( x > 0);
 i++;   // point to last valid character
 sprintf(so,"%s",s+i); // stick it in the temp string string
 return so;
}

char* pBinFill(long int x,char *so, char fillChar)
{ // fill in array from right to left
 char s[width+1];
 int    i=width;
 s[i--]=0x00;   // terminate string
 do
 {
  s[i--]=(x & 1) ? '1':'0';
  x>>=1;  // shift right 1 bit
 } while( x > 0);
 while(i>=0) s[i--]=fillChar;    // fill with fillChar 
 sprintf(so,"%s",s);
 return so;
}

void test()
{
 char so[width+1]; // working buffer for pBin
 long int   val=1;
 do
 {
   printf("%ld =\t\t%#lx =\t\t0b%s\n",val,val,pBinFill(val,so,0));
   val*=11; // generate test data
 } while (val < 100000000);
}

Output:
00000001 = 0x000001 =   0b00000000000000000000000000000001
00000011 = 0x00000b =   0b00000000000000000000000000001011
00000121 = 0x000079 =   0b00000000000000000000000001111001
00001331 = 0x000533 =   0b00000000000000000000010100110011
00014641 = 0x003931 =   0b00000000000000000011100100110001
00161051 = 0x02751b =   0b00000000000000100111010100011011
01771561 = 0x1b0829 =   0b00000000000110110000100000101001
19487171 = 0x12959c3 =  0b00000001001010010101100111000011

Answer 7

Se tiene que escribir su propia transformación. Sólo decimal, los números hexadecimales y octales son compatibles con los especificadores de formato.

Answer 8

No hay especificador de formato directo para esto en el lenguaje C. Aunque he escrito este fragmento pitón rápida para ayudarle a entender el proceso paso a paso para liar.

#!/usr/bin/python

dec = input("Enter a decimal number to convert: ")
base = 2
solution = ""

while dec >= base:
    solution = str(dec%base) + solution
    dec = dec/base
if dec > 0:
    solution = str(dec) + solution

print solution

Explicación:

Dec = entrada ( "Introduzca un número decimal para convertir:") - solicitar al usuario para la entrada numérica (hay múltiples maneras de hacer esto en C a través de scanf por ejemplo)

Base = 2 - especificar nuestra base es 2 (binario)

solución = "" - crear una cadena vacía en la que vamos a concatenar nuestra solución

mientras diciembre de base> =: - mientras que nuestro número es más grande que la base entró

solución = str (% de base dec) + solución - obtener el módulo de la serie a la base, y añadirlo al comienzo de nuestra cadena (hay que sumar los números de derecho de uso de la división de la izquierda y el método de resto). la función str () convierte el resultado de la operación en una cadena. No se puede concatenar números enteros con cadenas en Python sin una conversión de tipos.

Dec = Dec / base de - dividir el número decimal por la base en preparado para dar el siguiente módulo

si diciembre> 0:      solución = str (dec) + solución - si algo se deja sobre, agregarlo al comienzo (esto será 1, en todo caso)

solución de impresión - imprimir el número final