Десятичный в двоичный

Question

У меня есть число, которое я хотел бы преобразовать в двоичный (из десятичного числа) в C.

Я бы хотел, чтобы мой двоичный файл всегда был в 5 битах (десятичное число никогда не превышало 31).У меня уже есть функция, которая делает это вручную путем деления, но трудно заполнить ее до 5 битов.

Есть ли более простой способ?Возможно, с использованием побитового сдвига?

Я также хотел бы, чтобы двоичный файл был представлен в char *

Answer 1

Вот элегантное решение:

void getBin(int num, char *str)
{
  *(str+5) = '\0';
  int mask = 0x10 << 1;
  while(mask >>= 1)
    *str++ = !!(mask & num) + '0';
}

Здесь мы начнем с того, что строка заканчивается нулевым символом.Затем мы создаем маску, в которой есть только одна (ее можно было бы ожидать, сместив ее влево один раз, чтобы учесть смещение в первом прогоне условного оператора while).Каждый раз в цикле маска смещается на одну позицию вправо, а затем соответствующему символу присваивается значение «1» или «0» (!! гарантирует, что мы добавляем либо 0, либо 1до '0').Наконец, когда 1 в маске смещен из числа, цикл while заканчивается.

Чтобы проверить это, используйте следующее:

int main()
{
  char str[6];
  getBin(10, str);
  printf("%s\n", str);
  return 0;
}

Answer 2

Если вам не нужны начальные нули, вы можете просто использовать itoa (значение, outputtring, base)

Например

char s[9];
itoa(10, s, 2);
printf("%s\n", s);

распечатает

1010

В противном случае вы можете просто написать очень простую функцию.

void tobin5str(int value, char* output)
{
    int i;
    output[5] = '\0';
    for (i = 4; i >= 0; --i, value >>= 1)
    {
        output[i] = (value & 1) + '0';
    }
}

int main()
{
    char s[6];
    tobin5str(10, s);
    printf("%s\n", s);
    return 0;
}

распечатает

01010

Более общим подходом может быть функция, которая спрашивает вас, сколько бит нужно преобразовать.

void tobinstr(int value, int bitsCount, char* output)
{
    int i;
    output[bitsCount] = '\0';
    for (i = bitsCount - 1; i >= 0; --i, value >>= 1)
    {
        output[i] = (value & 1) + '0';
    }
}

Конечно, битCount должен иметь значение от 1 до 32, а строка буфера должна быть выделена как минимум для битов + 1 символов.

Answer 3

Один из подходов такой:

unsigned int x = 30;

char bits[] = "00000";

bits[4] = (x & 1) + '0';
x >>= 1;
bits[3] = (x & 1) + '0';
x >>= 1;
bits[2] = (x & 1) + '0';
x >>= 1;
bits[1] = (x & 1) + '0';
x >>= 1;
bits[0] = x + '0';

Вероятно, не самый элегантный подход ...

Answer 4

Вы всегда можете разделить и дополнить его до 5 бит (сделал это для заполнения в 8 бит, потому что печать символа как A была бы числом 65)

#include <stdio.h>
#include <math.h>
void main(){
int binary[8], number, i; //for 5 bits use binary[5]
do{
printf("input a number: ");
scanf("%d",&number);
fflush(stdin);
}while(number>256 || number <0); //for 5 bits... 31 use number>31 || number <0
for (i=0; i<=7; i++)  // for 5 bits use i<=4
    {
    binary[i]=number%2;
    number = number/2;
    }
for (i=7; i >=0; i--)  //for 5 bits use i=4
    printf("%d", binary[i]);
number=0; // its allready 0.
for (i=0; i<=7; i++)  //for 5 bits use i<=4
    {
    number=number+binary[i]*pow(2,i);
    }
printf("\n%c",number);
}

Answer 5

Для 31 значения вместо выполнения malloc для выделения строки с последующей битовой манипуляцией для ее заполнения вы можете просто использовать таблицу поиска.

static const char *bitstrings[] = {
    "00000", "00001", "00010", … "11111"
};

Тогда ваше преобразование так же просто, как return bitstrings[i]. Если вы делаете это часто, это будет быстрее (избегая malloc).

В противном случае вам не требуется никакого смещения (кроме как для облегчения записи ваших констант); Вы можете просто использовать бит-и:

char *bits = malloc(6);
bits[0] = (i & (1<<4)) ? '1' : '0';   /* you can also just write out the bit values, but the */
bits[1] = (i & (1<<3)) ? '1' : '0';   /* compiler should be able to optimize a constant!     */
⋮
bits[6] = 0; /* null-terminate string*/

Существует (возможно) микрооптимизация, которую вы можете выполнить, если предположите ASCII, используя сложение. Вы также можете использовать цикл здесь, но мне нужно было две строки для комментария :-P. С точки зрения производительности ни то, ни другое не будет иметь значения. Все время проводится в malloc.

Answer 6

#include "stdio.h"
#include "conio.h"

int main(void)
{
int i, d , n = 1;
int store[10];

printf("Please enter a number to be converted to binary:\n");
scanf("%d",&d);

for (i=0;i<8 ;i++ )
  store[i] = 0;

i = 0;

do{
if(d & n ){
    n <<= 1;  //10
    store[i] = 1;
    i++;
}
else {
    n <<= 1;
    store[i] = 0;
    i++;
}

}while(n <= d);

printf("\n");
for (i=7;i>=0 ;i-- ){
  printf("%d",store[i]);
if(i == 4)
    printf(" ");
}
printf("\n");
return 0;
}

Answer 7

int main() {
    int n,c,k;
    printf("Enter_an_integer_in_decimal_number_system:_");
    scanf("%d",&n);
    printf("%d_in_binary_number_system_is:_", n);
    for (c = n; c > 0; c = c/2) {
        k = c%2;
        k = (k>0)? printf("1"):printf("0");
    }
    getch();
    return 0;
}

Answer 8

Мой дубль:

char* to_bitstring(uint32_t val, char buffer[], int size) {
    buffer[--size] = 0;
    while (size > 0) {
        buffer[--size] = (val % 2 ? '1' : '0');
        val = val >> 1;
    }

    return buffer; /* convenience */
}

Это запишет символы РАЗМЕР в БУФЕР:

char buffer[17];
printf("%s\n", to_bitstring(42, buffer, sizeof(buffer)));

и напечатает:

0000000000101010

Answer 9

#include<stdio.h>

int mask = 1;
void decToBi(int);

void decToBi(int n){
    for(int j=15;j>=0;j--){
        int result;
        result = n & (mask<<j);
        if(result)
            printf("1");
        else
            printf("0");
    }    
}    
int main(){
    int n;
    scanf("%d",&n);
    decToBi(n);
    printf("\n");
return 0;
}

Надеюсь, это поможет

Answer 10

Здесь программа на C для преобразования десятичного числа в двоичное с использованием побитового оператора с любым десятичным числом, поддерживаемым системой и содержащим только необходимую память

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main (int argc, char **argv) 
{
    int n, t = 0;
    char *bin, b[2] = ""; 
    scanf("%d", &n);
    bin = (char*)malloc(sizeof(char) + 2);
    while (n != 0)
    {
        t = n >> 1;
        t = t << 1;
        t = n - t;
        n = n >> 1;
        itoa(t, b, 10);
        bin = realloc((char*)bin, sizeof(char) + 1);
        strcat(bin, b);
    }
    strrev(bin);
    printf("\n%s\n", bin);

    return 0 ;
}