用C將整數轉換為二進制

Question

我正在嘗試將整數 10 轉換為二進制數 1010。

這段代碼嘗試了它，但我在 strcat() 上遇到了段錯誤：

int int_to_bin(int k)
{
   char *bin;

   bin = (char *)malloc(sizeof(char));
   while(k>0) {
      strcat(bin, k%2);
      k = k/2;
      bin = (char *)realloc(bin, sizeof(char) * (sizeof(bin)+1));
   }
   bin[sizeof(bin)-1] = '\0';

   return atoi(bin);
}

如何在C中將整數轉換為二進制？

Answer 1

如果您想將一個數字轉換為另一個數字（不是數字到字符串），並且您可以使用一個小范圍（對於 32 位整數的實現為 0 到 1023），則不需要將char*添加到解決方案

unsigned int_to_int(unsigned k) {
    if (k == 0) return 0;
    if (k == 1) return 1;                       /* optional */
    return (k % 2) + 10 * int_to_int(k / 2);
}

HalosGhost建議將代碼壓縮為一行

unsigned int int_to_int(unsigned int k) {
    return (k == 0 || k == 1 ? k : ((k % 2) + 10 * int_to_int(k / 2)));
}

Answer 2

您需要初始化 bin，例如

bin = malloc(1);
bin[0] = '\0';

或使用 calloc：

bin = calloc(1, 1);

你這里也有一個錯誤：

 bin = (char *)realloc(bin, sizeof(char) * (sizeof(bin)+1));

這需要是：

 bin = (char *)realloc(bin, sizeof(char) * (strlen(bin)+1));

（即使用strlen ，而不是sizeof ）。

並且您應該在調用 strcat之前增加大小。

而且你沒有釋放 bin，所以你有內存泄漏。

並且您需要將 0, 1 轉換為 '0', '1'。

而且您不能將字符轉換為字符串。

所以除此之外，它很接近，但代碼應該更像這樣（警告，未經測試！）：

int int_to_bin(int k)
{
   char *bin;
   int tmp;

   bin = calloc(1, 1);
   while (k > 0)
   {
      bin = realloc(bin, strlen(bin) + 2);
      bin[strlen(bin) - 1] = (k % 2) + '0';
      bin[strlen(bin)] = '\0';
      k = k / 2;
   }
   tmp = atoi(bin);
   free(bin);
   return tmp;
}

Answer 3

只需使用itoa轉換為字符串，然后使用 atoi 轉換回十進制。

unsigned int_to_int(unsigned int k) {
    char buffer[65]; /* any number higher than sizeof(unsigned int)*bits_per_byte(8) */
    return atoi( itoa(k, buffer, 2) );
}

Answer 4

整數到二進制轉換的工作解決方案如下。

int main()
{
    int num=241; //Assuming 16 bit integer
    for(int i=15; i>=0; i--) cout<<((num >> i) & 1);
    cout<<endl;
    for(int i=0; i<16; i++) cout<<((num >> i) & 1);
    cout<<endl;
    return 0;
}

您可以根據自己的要求捕獲 cout<< 部分。

Answer 5

好吧，我遇到了同樣的麻煩……所以我找到了這個線程

我認為用戶的回答： “pmg”並不總是有效。

unsigned int int_to_int(unsigned int k) {
    return (k == 0 || k == 1 ? k : ((k % 2) + 10 * int_to_int(k / 2)));
}

原因：二進制表示存儲為整數。 那是相當有限的。 想象一下將十進制轉換為二進制：

 dec 255  -> hex 0xFF  -> bin 0b1111_1111
 dec 1023 -> hex 0x3FF -> bin 0b11_1111_1111

你必須存儲這個二進制表示，因為它是一個十進制數。

我認為Andy Finkenstadt的解決方案最接近您的需要

unsigned int_to_int(unsigned int k) {
    char buffer[65]; // any number higher than sizeof(unsigned int)*bits_per_byte(8)
    return itoa( atoi(k, buffer, 2) );
}

但這仍然不適用於大量。 毫不奇怪，因為您可能真的不需要將字符串轉換回十進制。 它的意義不大。 如果你需要一個二進制數，通常你需要一個文本在某處，所以將它保留為字符串格式。

只需使用itoa()

char buffer[65];
itoa(k, buffer, 2);

Answer 6

您可以使用函數此函數返回帶有整數字符串表示的char* ：

   char* itob(int i) {
      static char bits[8] = {'0','0','0','0','0','0','0','0'};
      int bits_index = 7;
      while ( i > 0 ) {
         bits[bits_index--] = (i & 1) + '0';
         i = ( i >> 1);
      }
      return bits;
   }

這不是一個完美的實現，但是如果您使用簡單的printf("%s", itob(170)) ，您將得到 01010101，因為我記得是 170。 添加atoi(itob(170)) ，您將獲得整數，但整數值絕對不是 170。

Answer 7

您可以使用此函數從整數中獲取位數組。

    int* num_to_bit(int a, int *len){
        int arrayLen=0,i=1;
        while (i<a){
            arrayLen++;
            i*=2;
        }
        *len=arrayLen;
        int *bits;
        bits=(int*)malloc(arrayLen*sizeof(int));
        arrayLen--;
        while(a>0){
            bits[arrayLen--]=a&1;
            a>>=1;
        }
        return bits;
     }

Answer 8

void intToBin(int digit) {
    int b;
    int k = 0;
    char *bits;

    bits= (char *) malloc(sizeof(char));
    printf("intToBin\n");
    while (digit) {
        b = digit % 2;
        digit = digit / 2;
        bits[k] = b;
        k++;

        printf("%d", b);
    }
    printf("\n");
    for (int i = k - 1; i >= 0; i--) {
        printf("%d", bits[i]);

    }

}

Answer 9

您可以按照此示例將十進制轉換為 bin、六進制轉換為十進制、六進制轉換為 bin，反之亦然等。 將十進制轉換為 BIN

int convert_to_bin(int number){
    int binary = 0, counter = 0;
    while(number > 0){
        int remainder = number % 2;
        number /= 2;
        binary += pow(10, counter) * remainder;
        counter++;
    }   
}

然后你可以像這樣打印二進制等價物：

printf("08%d", convert_to_bin(13)); //shows leading zeros

Answer 10

結果為字符串

以下函數將字符串中的整數轉換為二進制（n 是位數）：

// Convert an integer to binary (in a string)
void int2bin(unsigned integer, char* binary, int n=8)
{  
  for (int i=0;i<n;i++)   
    binary[i] = (integer & (int)1<<(n-i-1)) ? '1' : '0';
  binary[n]='\0';
}

在repl.it 上在線測試。

來源： AnsWiki 。

結果為具有內存分配的字符串

以下函數將字符串中的整數轉換為二進制並為字符串分配內存（n 是位數）：

// Convert an integer to binary (in a string)
char* int2bin(unsigned integer, int n=8)
{
  char* binary = (char*)malloc(n+1);
  for (int i=0;i<n;i++)   
    binary[i] = (integer & (int)1<<(n-i-1)) ? '1' : '0';
  binary[n]='\0';
  return binary;
}

這個選項允許你寫一些類似printf ("%s", int2bin(78)); 但要小心，為字符串分配的內存必須在以后空閑。

在repl.it 上在線測試。

來源： AnsWiki 。

結果為無符號整數

以下函數將一個整數轉換為另一個整數中的二進制（最多 8 位）：

// Convert an integer to binary (in an unsigned)
unsigned int int_to_int(unsigned int k) {
    return (k == 0 || k == 1 ? k : ((k % 2) + 10 * int_to_int(k / 2)));
}

在repl.it 上在線測試

顯示結果

以下函數顯示二進制轉換

// Convert an integer to binary and display the result
void int2bin(unsigned integer, int n=8)
{  
  for (int i=0;i<n;i++)   
    putchar ( (integer & (int)1<<(n-i-1)) ? '1' : '0' );
}

在repl.it 上在線測試。

來源： AnsWiki 。

Answer 11

您可以將這些函數添加到標准庫中，並在需要時隨時使用。

這是C++中的代碼

#include <stdio.h>

int power(int x, int y) //calculates x^y.
{
int product = 1;
for (int i = 0; i < y; i++)
{
    product = product * x;
}
return (product);
}
int gpow_bin(int a) //highest power of 2 less/equal to than number itself.
{
int i, z, t;
for (i = 0;; i++)
{
    t = power(2, i);
    z = a / t;
    if (z == 0)
    {
        break;
    }
}
return (i - 1);
}
void bin_write(int x)
{
//printf("%d", 1);
int current_power = gpow_bin(x);
int left = x - power(2, current_power);
int lower_power = gpow_bin(left);
for (int i = 1; i < current_power - lower_power; i++)
{
    printf("0");
}
if (left != 0)
{
    printf("%d", 1);
    bin_write(left);
}
}
void main()
{
//printf("%d", gpow_bin(67));
int user_input;
printf("Give the input:: ");
scanf("%d", &user_input);
printf("%d", 1);
bin_write(user_input);
}

Answer 12

#define BIT_WIDTH 32

char *IntToBin(unsigned n, char *buffer) {
    char *ptr = buffer + BIT_WIDTH;
    do {
        *(--ptr) = (n & 1) + '0';
        n >>= 1;
    } while(n);
    return ptr;
}

#define TEST 1

#if TEST
    #include <stdio.h>
    
    int main() {
        int n;
        char buff[BIT_WIDTH + 1];
        buff[BIT_WIDTH] = '\0';
        while(scanf("%d", &n) == 1) 
            puts(IntToBin(n, buff));
        return 0;
    }
#endif

Answer 13

short a;
short b;
short c;
short d;
short e;
short f;
short g;
short h;
int i;
char j[256];

printf("BINARY CONVERTER\n\n\n");

//uses <stdlib.h>

while(1)
{

a=0;
b=0;
c=0;
d=0;
e=0;
f=0;
g=0;
h=0;
i=0;


gets(j);
i=atoi(j);
if(i>255){
printf("int i must not pass the value 255.\n");
i=0;
}
if(i>=128){
a=1;
i=i-128;}
if(i>=64){
b=1;
i=i-64;}
if(i>=32){
c=1;
i=i-32;}
if(i>=16){
d=1;
i=i-16;}
if(i>=8){
e=1;
i=i-8;}
if(i>=4){
f=1;
i=i-4;}
if(i>=2){
g=1;
i=i-2;}
if(i>=1){
h=1;
i=i-1;}

printf("\n%d%d%d%d%d%d%d%d\n\n",a,b,c,d,e,f,g,h);
}