Отобразить двоичное представление числа в C?

Question

Можно создать дубликат:
Is there a printf converter to print in binary format?

Еще обучения C и мне было интересно:

Учитывая ряд, можно сделать что-то вроде следующего?

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

Или мне нужно написать собственный метод для преобразования в двоичный файл?

Answer 1

Да (напишите сами), что-то вроде следующей полной функции.

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

Добавить это главное в конце его, чтобы увидеть его в действии:

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

Выполнить его "progname 0 7 12 52 123" получить:

[ 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

Вы должны написать собственное преобразование. Только десятичные, шестнадцатеричные и восьмеричные числа поддерживаются спецификаторами формата.

Answer 3

Нет прямого пути (то есть с использованием printf или другой стандартной библиотечной функции) для его печати. Вам нужно будет написать свою собственную функцию.

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

Если вы используете терминал, вы можете использовать коды управления для вывода байтов в естественном порядке:

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

Там нет прямого спецификатор формата для этого в языке Си. Хотя я написал этот быстрый фрагмент python, чтобы помочь вам понять процесс шаг за шагом, чтобы сворачивать ваши собственные.

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

Разъяснение:

Декабрь = вход («Введите десятичное число для преобразования:») - запрашивать у пользователя числового ввода (есть несколько способов сделать это в C через зсап например)

база = 2 - указать, наша база 2 (двоичный)

решение = «» - создать пустую строку, в которой мы будем конкатенировать наше решение

то время как разл> = базовый: - в то время как наш номер больше, чем основание введенной

решение = Str (реш% base) + solution - получить модуль числа до базы и добавить его в начало нашей строки (мы должны добавить числа справа налево, используя метод деления и остатка). функция str() преобразует результат операции в строку. Вы не можете конкатенировать целые числа со строками в python без преобразования типов.

декабрь = декабрь/базовая - разделить десятичное число на базе в Preperation, чтобы сделать следующий по модулю

, если декабрь> 0: решение = ул (разл) + раствор - если ничего, что осталось, добавить его в начало (это будет 1, если что-нибудь)

решения для печати - печать окончательного числа

Answer 5

Используйте таблицу поиска, например:

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

then prin т каждый грызть, как этот

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

Конечно, вы можете использовать только один стол, но это будет немного быстрее и слишком большой.

Answer 6

на основе dirkgently's answer, но устремив две ошибки, и всегда печати фиксированное количество цифр:

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

Answer 7

Этот код должен обрабатывать ваши потребности до 64 бит.

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