У меня есть число, которое я хотел бы преобразовать в двоичный (из десятичной) в C.
Я бы хотел, чтобы мой двоичный файл всегда был в 5 бит (десятичная цифра никогда не будет превышать 31). У меня уже есть функция, которая делает это вручную, деля, но это трудно отнести до 5 бит.
Есть ли более простой способ? Возможно, используя побитовый сдвиг?
Мне также хотелось бы, чтобы двоичный файл представлялся в char *
Здесь элегантное решение:
void getBin(int num, char *str)
{
*(str+5) = '\0';
int mask = 0x10 << 1;
while(mask >>= 1)
*str++ = !!(mask & num) + '0';
}
Здесь мы начинаем с того, что строка заканчивается нулевым символом. Затем мы создаем маску с одним в ней (ее маска, которую вы ожидаете, сдвигается влево один раз, чтобы учитывать сдвиг в первом прогоне условного). Каждый раз через цикл маска сдвигается на одно место вправо, а затем соответствующему символу присваивается либо "1", либо "0" (!! убедитесь, что мы добавляем либо 0, либо 1 до '0'). Наконец, когда 1 в маске смещается из числа, контур while заканчивается.
Чтобы протестировать его, используйте следующее:
int main()
{
char str[6];
getBin(10, str);
printf("%s\n", str);
return 0;
}
Если вам не нужны ведущие нули, вы можете просто использовать itoa (value, outputstring, 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';
}
}
Конечно, bitsCount должен быть значением от 1 до 32, а буферная строка должна быть назначена для, по меньшей мере, битCount + 1 символ.
Один из подходов заключается в следующем:
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';
Вероятно, не самый элегантный подход...
Для 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.
Вы всегда можете разделить и поместить его на 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);
}
Поскольку вы работаете только с 5 битами, почему бы не использовать таблицу поиска? Что-то вроде следующего:
/* Convert nstr to a number (decimal) and put a string representation of the
* lowest 5 bits in dest (which must be at least 6 chars long) */
void getBinStr(char *dest, const char *nstr)
{
char *lkup[32] = {
"00000", "00001", "00010", "00011", "00100", "00101", "00110", "00111",
"01000", "01001", "01010", "01011", "01100", "01101", "01110", "01111",
"10000", "10001", "10010", "10011", "10100", "10101", "10110", "10111",
"11000", "11001", "11010", "11011", "11100", "11101", "11110", "11111" };
strcpy(dest, lkup[atoi(nstr) & 0x1f]);
}
Или переключатель:
void getBinStr(char *dest, const char *nstr)
{
switch (atoi(nstr)) {
case 31: strcpy(dest,"11111"); break;
case 30: strcpy(dest,"11110"); break;
...
case 1: strcpy(dest,"00001"); break;
case 0: strcpy(dest,"00000"); break;
default: strcpy(dest,"error");
}
}
Или, если это кажется слишком длинным, возможно, что-то вроде следующего:
void getBinStr(char *dest, const char *nstr)
{
unsigned x = atoi(nstr);
dest[0] = (x & 0x10) ? '1' : '0';
dest[1] = (x & 0x08) ? '1' : '0';
dest[2] = (x & 0x04) ? '1' : '0';
dest[3] = (x & 0x02) ? '1' : '0';
dest[4] = (x & 0x01) ? '1' : '0';
dest[5] = '\0';
}
Обычно я предпочитаю одно из первых двух, но последнее может быть лучше, если по какой-то причине другие слишком большие (например, для небольшого микроконтроллера).
Все это предполагает, что вы хотите, чтобы результат оставался заполненным нулями до 5 бит.
#include <stdio.h>
#include <string.h>
char numstr[9024];
int i = 0;
void format(int n, int base);
void printreverse(char *s);
int main()
{
int testnum = 312; // some random test number
format(testnum, 2); // 2 for binary
printreverse(numstr);
putchar('\n');
return 0;
}
void format(int n, int base)
{
if (n > 0) {
char tmp = (n % base) + '0';
numstr[i++] = tmp;
// If we put this above other two we don't need printreverse,
// But then we will have unwanted results in other places of numstr if we can't reset it
format(n/base, base);
} else
numstr[i] = '\0'; // terminating character
}
void printreverse(char *s)
{
long len = strlen(s);
while (len-->0)
putchar(s[len]);
}
Здесь программа 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 ;
}
#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;
}
Надеюсь, что это поможет
Мой прием:
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 */
}
Это приведет к записи символов SIZE в BUFFER:
char buffer[17];
printf("%s\n", to_bitstring(42, buffer, sizeof(buffer)));
И напечатает:
0000000000101010
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;
}
#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;
}