Hiển thị biểu diễn nhị phân của một số trong C?

Question

thể trùng lặp:
Is there a printf converter to print in binary format?

Tuy nhiên việc học C và tôi đã tự hỏi:

Cho một số, là nó có thể làm điều gì đó như sau?

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

Hoặc tôi có phải viết phương pháp của riêng mình để thực hiện chuyển đổi sang nhị phân không?

Answer 1

Có (viết của riêng bạn), một cái gì đó giống như chức năng hoàn chỉnh sau đây.

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

Thêm chính này để kết thúc của nó để xem nó đi vào hoạt động:

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

Run nó với "progname 0 7 12 52 123" để có được:

[ 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

Bạn phải viết phép biến đổi của riêng mình. Chỉ số thập phân, thập lục phân và bát phân được hỗ trợ với các định dạng thông số định dạng.

Answer 3

Không có cách nào trực tiếp (tức là sử dụng printf hoặc chức năng thư viện chuẩn khác) để in. Bạn sẽ phải viết chức năng của riêng bạ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)); 
} 

Nếu bạn đang sử dụng thiết bị đầu cuối, bạn có thể sử dụng mã điều khiển để in ra byte trong trật tự tự nhiên:

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

Answer 4

Không có specifier định dạng trực tiếp cho điều này bằng ngôn ngữ C. Mặc dù tôi đã viết đoạn mã python nhanh này để giúp bạn hiểu từng bước để tự cuộn.

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

Giải thích:

Tháng Mười Hai = input ("Nhập số thập phân để chuyển đổi:") - nhắc nhở người dùng cho đầu vào số (có nhiều cách để làm điều này trong C qua scanf ví dụ)

cơ sở = 2 - chỉ định cơ sở của chúng tôi là 2 (nhị phân)

giải pháp = "" - tạo ra một chuỗi rỗng trong đó chúng ta sẽ tiếp nhau giải pháp của chúng tôi

trong khi tháng mười hai> = cơ sở: - trong khi số lượng của chúng tôi lớn hơn cơ sở vào

giải pháp = str (DEC% cơ sở) + giải pháp - lấy mô-đun của số đó đến cơ số và thêm nó vào đầu chuỗi của chúng ta (chúng ta phải thêm các số từ phải sang trái bằng cách sử dụng phép chia và phương thức còn lại). hàm str() chuyển đổi kết quả của hoạt động thành một chuỗi. Bạn không thể nối các số nguyên với các chuỗi trong python mà không cần chuyển đổi kiểu.

Tháng Mười Hai = Tháng Mười Hai/cơ sở - chia số thập phân bởi các cơ sở trong quá trình chuẩn bị để có những modulo tiếp theo

nếu tháng mười hai> 0: giải pháp = str (DEC) + giải pháp - nếu bất cứ điều gì còn sót lại, thêm nó vào đầu (điều này sẽ là 1, nếu bất cứ điều gì)

giải pháp in - in con số cuối cùng

Answer 5

Sử dụng một bảng tra cứu, như:

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

sau đó prin t mỗi nibble như thế này

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

Chắc chắn bạn chỉ có thể sử dụng một bảng nhưng sẽ nhanh hơn và quá lớn.

Answer 6

Dựa trên dirkgently's answer, nhưng sửa hai lỗi của mình, và luôn luôn in một số cố định của các chữ số:

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

Answer 7

Mã này nên xử lý nhu cầu của bạn lên đến 64 bit.

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 8

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