Wyświetla binarną reprezentację liczby w C? [duplikat]

Nie ma bezpośredniego sposobu (tj. użycia printf lub innej standardowej funkcji bibliotecznej), aby ją wydrukować. Będziesz musiał napisać własną funkcję.

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

Jeśli używasz terminala, możesz użyć kodów sterujących do drukowania bajtów w naturalnej kolejności:

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

Na podstawie dirkgently ' s answer , ale naprawia dwa błędy i zawsze drukuje stałą liczbę cyfr:

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

#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;
}

Użyj tabeli wyszukiwania, Jak:

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

Następnie wydrukuj każdy skubek w ten sposób

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

Z pewnością możesz użyć tylko jednego stołu, ale będzie on nieznacznie szybszy i zbyt duży.

Ten kod powinien obsłużyć twoje potrzeby do 64 bitów.

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 &gt 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

Musisz napisać własną transformację. Tylko liczby dziesiętne, szesnastkowe i ósemkowe są obsługiwane przez SPECYFIKATORY FORMATU.

W języku C nie ma bezpośredniego określenia formatu. Chociaż napisałem ten szybki fragment Pythona, aby pomóc ci zrozumieć proces krok po kroku, aby rzucić własne.

#!/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

Explained:

Dec = input ("Enter a decimal number to convert:") - pyta użytkownika o wejście numeryczne (istnieje wiele sposobów, aby to zrobić w C przez scanf na przykład)

Base = 2 - podaj naszą Bazę to 2 (binary)

Solution = "" - Utwórz pusty łańcuch, w którym połączymy nasze rozwiązanie

While dec > = base: - while nasza liczba jest większa od wprowadzonej Bazy

Solution = str ( dec % base) + solution - pobieramy moduł liczby do bazy i dodajemy ją do początku naszego łańcucha (musimy dodać liczby od prawej do lewej używając metody division I rest). funkcja str () zamienia wynik operacji na łańcuch znaków. Nie można łączyć liczb całkowitych z łańcuchami w Pythonie bez konwersji typu.

Dec = Dec / base - podziel liczbę dziesiętną przez bazę w preperacji, aby wziąć następny modulo

If dec > 0: solution = str (dec) + solution - jeśli cokolwiek zostanie, dodaj go do początku (będzie to 1, jeśli już)

Print solution - wypisuje ostateczną liczbę