C ++-十进制到二进制转换

我写了一个“简单”（花了我30分钟）程序，将十进制数转换为二进制。我敢肯定，有很多简单的方法，所以你可以告诉我吗？这是代码：

#include <iostream>
#include <stdlib.h>

using namespace std;
int a1, a2, remainder;
int tab = 0;
int maxtab = 0;
int table[0];
int main()
{
    system("clear");
    cout << "Enter a decimal number: ";
    cin >> a1;
    a2 = a1; //we need our number for later on so we save it in another variable

    while (a1!=0) //dividing by two until we hit 0
    {
        remainder = a1%2; //getting a remainder - decimal number(1 or 0)
        a1 = a1/2; //dividing our number by two
        maxtab++; //+1 to max elements of the table
    }

    maxtab--; //-1 to max elements of the table (when dividing finishes it adds 1 additional elemnt that we don't want and it's equal to 0)
    a1 = a2; //we must do calculations one more time so we're gatting back our original number
    table[0] = table[maxtab]; //we set the number of elements in our table to maxtab (we don't get 10's of 0's)

    while (a1!=0) //same calculations 2nd time but adding every 1 or 0 (remainder) to separate element in table
    {
        remainder = a1%2; //getting a remainder
        a1 = a1/2; //dividing by 2
        table[tab] = remainder; //adding 0 or 1 to an element
        tab++; //tab (element count) increases by 1 so next remainder is saved in another element
    }

    tab--; //same as with maxtab--
    cout << "Your binary number: ";

    while (tab>=0) //until we get to the 0 (1st) element of the table
    {
        cout << table[tab] << " "; //write the value of an element (0 or 1)
        tab--; //decreasing by 1 so we show 0's and 1's FROM THE BACK (correct way)
    }

    cout << endl;
    return 0;
}

顺便说一下，它很复杂，但是我尽了最大的努力。

编辑-这是我最终使用的解决方案：

std::string toBinary(int n)
{
    std::string r;
    while(n!=0) {r=(n%2==0 ?"0":"1")+r; n/=2;}
    return r;
}

std::bitset有一个.to_string()方法，该方法返回一个std::string以二进制形式（带有前导零填充）的文本表示形式。

根据数据需要选择位集的宽度，例如std::bitset<32>，从32位整数中获取32个字符的字符串。

#include <iostream>
#include <bitset>

int main()
{
    std::string binary = std::bitset<8>(128).to_string(); //to binary
    std::cout<<binary<<"\n";

    unsigned long decimal = std::bitset<8>(binary).to_ulong();
    std::cout<<decimal<<"\n";
    return 0;
}

编辑：请不要编辑我的八进制和十六进制答案。OP专门要求“十进制转换为二进制”。

以下是一个递归函数，该函数采用一个正整数并将其二进制数字输出到控制台。

亚历克斯建议，为了提高效率，您可能需要删除printf()结果并将其存储在内存中...根据存储方法的不同，结果可能会相反。

/**
 * Takes a unsigned integer, converts it into binary and prints it to the console.
 * @param n the number to convert and print
 */
void convertToBinary(unsigned int n)
{
    if (n / 2 != 0) {
        convertToBinary(n / 2);
    }
    printf("%d", n % 2);
}

归功于UoA ENGGEN 131

*注意：使用unsigned int的好处是它不能为负数。

您可以使用std :: bitset将数字转换为其二进制格式。

使用以下代码段：

std::string binary = std::bitset<8>(n).to_string();

我在stackoverflow本身上找到了这个。我附上了链接。

一个很简单的打印二进制文件的解决方案：

#include <iostream>
using namespace std;
int main()
{
 int num,arr[64];
 cin>>num;
 int i=0,r;
 while(num!=0)
{
  r = num%2;
  arr[i++] = r;
  num /= 2;
}

for(int j=i-1;j>=0;j--){
 cout<<arr[j];
  }
}

非递归解决方案：

#include <iostream>
#include<string>


std::string toBinary(int n)
{
    std::string r;
    while(n!=0) {r=(n%2==0 ?"0":"1")+r; n/=2;}
    return r;
}
int main()
{
    std::string i= toBinary(10);
    std::cout<<i;
}

递归解决方案：

#include <iostream>
#include<string>

std::string r="";
std::string toBinary(int n)
{
    r=(n%2==0 ?"0":"1")+r;
    if (n / 2 != 0) {
        toBinary(n / 2);
    }
    return r;
}
int main()
{
    std::string i=toBinary(10);
    std::cout<<i;
}

这是两种方法。一个类似于您的方法

#include <iostream>
#include <string>
#include <limits>
#include <algorithm>

int main()
{
    while ( true )
    {
        std::cout << "Enter a non-negative number (0-exit): ";

        unsigned long long x = 0;
        std::cin >> x;

        if ( !x ) break;

        const unsigned long long base = 2;

        std::string s;
        s.reserve( std::numeric_limits<unsigned long long>::digits ); 

        do { s.push_back( x % base + '0' ); } while ( x /= base );

        std::cout << std::string( s.rbegin(), s.rend() )  << std::endl;
    }
}

其他建议使用std :: bitset。

#include <iostream>
#include <string>
#include <bitset>
#include <limits>

int main()
{
    while ( true )
    {
        std::cout << "Enter a non-negative number (0-exit): ";

        unsigned long long x = 0;
        std::cin >> x;

        if ( !x ) break;

        std::string s = 
            std::bitset<std::numeric_limits<unsigned long long>::digits>( x ).to_string();

        std::string::size_type n = s.find( '1' ); 
        std::cout << s.substr( n )  << std::endl;
    }
}

一个int变量是不是小数，它的二进制。您正在寻找的是数字的二进制字符串表示形式，可以通过应用过滤单个位的掩码然后打印出来来获得：

for( int i = sizeof(value)*CHAR_BIT-1; i>=0; --i)
    cout << value & (1 << i) ? '1' : '0';

如果您的问题是算法性的，那就是解决方案。如果没有，则应使用std :: bitset类为您处理此问题：

bitset< sizeof(value)*CHAR_BIT > bits( value );
cout << bits.to_string();

从自然数到二进制字符串的转换：

string toBinary(int n) {
    if (n==0) return "0";
    else if (n==1) return "1";
    else if (n%2 == 0) return toBinary(n/2) + "0";
    else if (n%2 != 0) return toBinary(n/2) + "1";
}

这是现代的变体，可以用于ints不同的尺寸。

#include <type_traits>
#include <bitset>

template<typename T>
std::enable_if_t<std::is_integral_v<T>,std::string>
encode_binary(T i){
    return std::bitset<sizeof(T) * 8>(i).to_string();
}

您想要执行以下操作：

cout << "Enter a decimal number: ";
cin >> a1;
cout << setbase(2);
cout << a1

十进制到二进制无数组* Oya制造：

我仍然是初学者，因此此代码将仅使用循环和变量xD ...

希望你喜欢。这可能比实际上更简单...

    #include <iostream>
    #include <cmath>
    #include <cstdlib>

    using namespace std;

    int main()
    {
        int i;
        int expoentes; //the sequence > pow(2,i) or 2^i
        int decimal; 
        int extra; //this will be used to add some 0s between the 1s
        int x = 1;

        cout << "\nThis program converts natural numbers into binary code\nPlease enter a Natural number:";
        cout << "\n\nWARNING: Only works until ~1.073 millions\n";
        cout << "     To exit, enter a negative number\n\n";

        while(decimal >= 0){
            cout << "\n----- // -----\n\n";
            cin >> decimal;
            cout << "\n";

            if(decimal == 0){
                cout << "0";
            }
            while(decimal >= 1){
                i = 0;
                expoentes = 1;
                while(decimal >= expoentes){
                    i++;
                    expoentes = pow(2,i);
                }
                x = 1;
                cout << "1";
                decimal -= pow(2,i-x);
                extra = pow(2,i-1-x);
                while(decimal < extra){
                    cout << "0";
                    x++;
                    extra = pow(2,i-1-x);
                }
            }
        }
        return 0;
    }

这里是一个std::string用作容器的简单转换器。它允许一个负值。

#include <iostream>
#include <string>
#include <limits>

int main()
{
    int x = -14;

    int n = std::numeric_limits<int>::digits - 1;

    std::string s;
    s.reserve(n + 1);

    do
        s.push_back(((x >> n) & 1) + '0');
    while(--n > -1);

    std::cout << s << '\n';
}

这是一个比以往更简单的程序

//Program to convert Decimal into Binary
#include<iostream>
using namespace std;
int main()
{
    long int dec;
    int rem,i,j,bin[100],count=-1;
    again:
    cout<<"ENTER THE DECIMAL NUMBER:- ";
    cin>>dec;//input of Decimal
    if(dec<0)
    {
        cout<<"PLEASE ENTER A POSITIVE DECIMAL";
        goto again;
    }
    else
        {
        cout<<"\nIT's BINARY FORM IS:- ";
        for(i=0;dec!=0;i++)//making array of binary, but reversed
        {
            rem=dec%2;
            bin[i]=rem;
            dec=dec/2;
            count++;
        }
        for(j=count;j>=0;j--)//reversed binary is printed in correct order
        {
            cout<<bin[j];
        }
    }
    return 0; 
}

实际上，有一种非常简单的方法。我们使用的是递归函数，该函数在参数中指定了数字（int）。这很容易理解。您也可以添加其他条件/变量。这是代码：

int binary(int num)
{
    int rem;
    if (num <= 1)
        {
            cout << num;
            return num;
        }
    rem = num % 2;
    binary(num / 2);
    cout << rem;
    return rem;
}

#include "stdafx.h"
#include<iostream>
#include<vector>
#include<cmath>

using namespace std;

int main() {
    // Initialize Variables
    double x;
    int xOct;
    int xHex;

    //Initialize a variable that stores the order if the numbers in binary/sexagesimal base
    vector<int> rem;

    //Get Demical value
    cout << "Number (demical base): ";
    cin >> x;

    //Set the variables
    xOct = x;
    xHex = x;

    //Get the binary value
    for (int i = 0; x >= 1; i++) {
        rem.push_back(abs(remainder(x, 2)));
        x = floor(x / 2);
    }

    //Print binary value
    cout << "Binary: ";
    int n = rem.size();
    while (n > 0) {
        n--;
        cout << rem[n];
    } cout << endl;

    //Print octal base
    cout << oct << "Octal: " << xOct << endl;

    //Print hexademical base
    cout << hex << "Hexademical: " << xHex << endl;

    system("pause");
    return 0;
}

#include <iostream>
using namespace std;

int main()
{  
    int a,b;
    cin>>a;
    for(int i=31;i>=0;i--)
    {
        b=(a>>i)&1;
        cout<<b;
    }
}

HOPE YOU LIKE THIS SIMPLE CODE OF CONVERSION FROM DECIMAL TO BINARY


  #include<iostream>
    using namespace std;
    int main()
    {
        int input,rem,res,count=0,i=0;
        cout<<"Input number: ";
        cin>>input;`enter code here`
        int num=input;
        while(input > 0)
        {
            input=input/2;  
            count++;
        }

        int arr[count];

        while(num > 0)
        {
            arr[i]=num%2;
            num=num/2;  
            i++;
        }
        for(int i=count-1 ; i>=0 ; i--)
        {
            cout<<" " << arr[i]<<" ";
        }



        return 0;
    }

std::string bin(uint_fast8_t i){return !i?"0":i==1?"1":bin(i/2)+(i%2?'1':'0');}

// function to convert decimal to binary
void decToBinary(int n)
{
    // array to store binary number
    int binaryNum[1000];

    // counter for binary array
    int i = 0;
    while (n > 0) {

        // storing remainder in binary array
        binaryNum[i] = n % 2;
        n = n / 2;
        i++;
    }

    // printing binary array in reverse order
    for (int j = i - 1; j >= 0; j--)
        cout << binaryNum[j];
}

请参阅：-https : //www.geeksforgeeks.org/program-decimal-binary-conversion/

或使用功能：-

#include<bits/stdc++.h>
using namespace std;

int main()
{

    int n;cin>>n;
    cout<<bitset<8>(n).to_string()<<endl;


}

或使用左移

#include<bits/stdc++.h>
using namespace std;
int main()
{
    // here n is the number of bit representation we want 
    int n;cin>>n;

    // num is a number whose binary representation we want
    int num;
    cin>>num;

    for(int i=n-1;i>=0;i--)
    {
        if( num & ( 1 << i ) ) cout<<1;
        else cout<<0;
    }


}

为此，在C ++中，您可以使用itoa（）函数。此函数将任何十进制整数转换为二进制，十进制，十六进制和八进制数。

#include<bits/stdc++.h>
using namespace std;
int main(){
 int a;    
 char res[1000];
 cin>>a;
 itoa(a,res,10);
 cout<<"Decimal- "<<res<<endl;
 itoa(a,res,2);
 cout<<"Binary- "<<res<<endl;
 itoa(a,res,16);
 cout<<"Hexadecimal- "<<res<<endl;
 itoa(a,res,8);
 cout<<"Octal- "<<res<<endl;return 0;
}

但是，仅特定编译器支持。

您还可以看到：itoa- C ++参考

#include <iostream>
#include <bitset>

#define bits(x)  (std::string( \
            std::bitset<8>(x).to_string<char,std::string::traits_type, std::string::allocator_type>() ).c_str() )


int main() {

   std::cout << bits( -86 >> 1 ) << ": " << (-86 >> 1) << std::endl;

   return 0;
}

好的..我可能对C ++有点陌生，但是我觉得上面的示例并不能很好地完成工作。

这是我对这种情况的看法。

char* DecimalToBinary(unsigned __int64 value, int bit_precision)
{
    int length = (bit_precision + 7) >> 3 << 3;
    static char* binary = new char[1 + length];
    int begin = length - bit_precision;
    unsigned __int64 bit_value = 1;
    for (int n = length; --n >= begin; )
    {
        binary[n] = 48 | ((value & bit_value) == bit_value);
        bit_value <<= 1;
    }
    for (int n = begin; --n >= 0; )
        binary[n] = 48;

    binary[length] = 0;
    return binary;
}

@value =我们正在检查的值。

@bit_precision =要检查的最左最高位。

@Length =最大字节块大小。例如7 = 1字节和9 = 2字节，但是我们以位的形式表示，因此1 Byte = 8位。

@binary =我给调用我们设置的字符数组的一个哑巴名称。我们将其设置为静态，因此不会在每次调用时都重新创建。为了简单地获取结果并显示它，这很好用，但是如果您要在UI上显示多个结果，它们将全部显示为最后一个结果。可以通过删除static来解决此问题，但是请确保在完成操作后删除[]结果。

@begin =这是我们正在检查的最低索引。超出此点的所有内容都将被忽略。或者如第二循环所示设置为0。

@first循环-在这里，我们将值设置为48，并根据（value＆bit_value）== bit_value的布尔值将0或1基本上添加到48。如果为true，则将char设置为49。如果为false，则将char设置为48。然后，将bit_value移位或基本上乘以2。

@second循环-在这里，我们将所有被忽略的索引设置为48或'0'。

一些示例输出！！！

int main()
{
    int val = -1;
    std::cout << DecimalToBinary(val, 1) << '\n';
    std::cout << DecimalToBinary(val, 3) << '\n';
    std::cout << DecimalToBinary(val, 7) << '\n';
    std::cout << DecimalToBinary(val, 33) << '\n';
    std::cout << DecimalToBinary(val, 64) << '\n';
    std::cout << "\nPress any key to continue. . .";
    std::cin.ignore();
    return 0;
}

00000001 //Value = 2^1 - 1
00000111 //Value = 2^3 - 1.
01111111 //Value = 2^7 - 1.
0000000111111111111111111111111111111111 //Value = 2^33 - 1.
1111111111111111111111111111111111111111111111111111111111111111 //Value = 2^64 - 1.

速度测试

原始问题的答案：“方法：toBinary（int）;”

执行：10,000，总时间（百万）：4701.15，平均时间（纳秒）：470114

我的版本：“方法：DecimalToBinary（int，int）;”

//使用64位精度。

执行：10,000,000，总时间（百万）：3386，平均时间（纳秒）：338

//使用1位精度。

执行：10,000,000，总时间（百万）：634，平均时间（纳秒）：63

#include <iostream>

// x is our number to test
// pow is a power of 2 (e.g. 128, 64, 32, etc...)
int printandDecrementBit(int x, int pow)
{
    // Test whether our x is greater than some power of 2 and print the bit
    if (x >= pow)
    {
        std::cout << "1";
        // If x is greater than our power of 2, subtract the power of 2
        return x - pow;
    }
    else
    {
        std::cout << "0";
        return x;
    }
}

int main()
{
    std::cout << "Enter an integer between 0 and 255: ";
    int x;
    std::cin >> x;

    x = printandDecrementBit(x, 128);
    x = printandDecrementBit(x, 64);
    x = printandDecrementBit(x, 32);
    x = printandDecrementBit(x, 16);

    std::cout << " ";

    x = printandDecrementBit(x, 8);
    x = printandDecrementBit(x, 4);
    x = printandDecrementBit(x, 2);
    x = printandDecrementBit(x, 1);

    return 0;
}

这是获取int二进制形式的简单方法。归功于learningcpp.com。我肯定可以用不同的方式达到目的。

用这种方法，十进制将转换为字符串formate中的相应二进制数。的字符串返回类型被选择，因为它可以处理更多的输入值范围。

class Solution {
public:
  string ConvertToBinary(int num) 
  {
    vector<int> bin;
    string op;
    for (int i = 0; num > 0; i++)
    {
      bin.push_back(num % 2);
      num /= 2;
    }
    reverse(bin.begin(), bin.end());
    for (size_t i = 0; i < bin.size(); ++i)
    {
      op += to_string(bin[i]);
    }
    return op;
  }
};

我在C ++中将十进制转换为二进制的方式。但是由于我们使用的是mod，因此该功能在十六进制或八进制的情况下也可以使用。您也可以指定位。此函数将继续计算最低有效位，并将其放置在字符串的末尾。如果您与这种方法不太相似，可以访问以下网址：https ://www.wikihow.com/Convert-from-Decimal-to-Binary

#include <bits/stdc++.h>
using namespace std;

string itob(int bits, int n) {
    int c;
    char s[bits+1]; // +1 to append NULL character.

    s[bits] = '\0'; // The NULL character in a character array flags the end of the string, not appending it may cause problems.

    c = bits - 1; // If the length of a string is n, than the index of the last character of the string will be n - 1. Cause the index is 0 based not 1 based. Try yourself.

    do {
        if(n%2) s[c] = '1';
        else s[c] = '0';
        n /= 2;
        c--;
    } while (n>0);

    while(c > -1) {
        s[c] = '0';
        c--;
}

    return s;
}

int main() {
    cout << itob(1, 0) << endl; // 0 in 1 bit binary.
    cout << itob(2, 1) << endl; // 1 in 2 bit binary.
    cout << itob(3, 2) << endl; // 2 in 3 bit binary.
    cout << itob(4, 4) << endl; // 4 in 4 bit binary.
    cout << itob(5, 15) << endl; // 15 in 5 bit binary.
    cout << itob(6, 30) << endl; // 30 in 6 bit binary.
    cout << itob(7, 61) << endl; // 61 in 7 bit binary.
    cout << itob(8, 127) << endl; // 127 in 8 bit binary.
    return 0;
}

输出：

0
01
010
0100
01111
011110
0111101
01111111

您的解决方案需要修改。最后的字符串应在返回之前反转：

std::reverse(r.begin(), r.end());
return r;

使用bitmask和bitwise和。

string int2bin(int n){
    string x;
    for(int i=0;i<32;i++){
        if(n&1) {x+='1';}
        else {x+='0';}
        n>>=1;
    }
    reverse(x.begin(),x.end());
    return x;
}

下面是简单的C代码，它将二进制转换为十进制然后再次返回。我写了很久以前的一个项目中，目标是嵌入式处理器和开发工具，有一个STDLIB这是方式太大固件ROM。

这是通用C代码，不使用任何库，也不使用除法或余数（％）运算符（这在某些嵌入式处理器上很慢），也不使用任何浮点数，也不使用任何表查找或模拟任何BCD算术。它真正使用的是type long long，更具体地说是unsigned long long（或uint64_t）类型，因此，如果嵌入式处理器（及其附带的C编译器）无法执行64位整数运算，则此代码不适用于您的应用程序。否则，我认为这是产品质量的C代码（改变后可能long要int32_t和unsigned long long到uint64_t）。我已经通宵进行了测试，以针对每个2³²有符号整数值进行测试，并且在任一方向上的转换都没有错误。

我们有一个可以生成可执行文件的C编译器/链接器，我们需要做一些没有任何stdlib（这是猪）的事情。因此，也printf()没有scanf()。甚至sprintf()都不是sscanf()。但是我们仍然有一个用户界面，并且必须将以10为基数的数字转换为二进制，然后再转换为二进制。（我们还组成了自己的malloc()类实用程序以及我们自己的先验数学函数。）

因此，这就是我的操作方式（该main程序和对stdlib的调用可以在我的Mac上测试此东西，而不是用于嵌入式代码）。另外，由于某些较旧的dev系统无法识别“ int64_t”和“ uint64_t”以及相似的类型，因此使用和假定类型long long和unsigned long long相同。并long假定为32位。我想我可以吃的typedef。

// returns an error code, 0 if no error,
// -1 if too big, -2 for other formatting errors
int decimal_to_binary(char *dec, long *bin)
    {
    int i = 0;
    
    int past_leading_space = 0;
    while (i <= 64 && !past_leading_space)        // first get past leading spaces
        {
        if (dec[i] == ' ')
            {
            i++;
            }
         else
            {
            past_leading_space = 1;
            }
        }
    if (!past_leading_space)
        {
        return -2;                                // 64 leading spaces does not a number make
        }
    // at this point the only legitimate remaining
    // chars are decimal digits or a leading plus or minus sign

    int negative = 0;
    if (dec[i] == '-')
        {
        negative = 1;
        i++;
        }
     else if (dec[i] == '+')
        {
        i++;                                    // do nothing but go on to next char
        }
    // now the only legitimate chars are decimal digits
    if (dec[i] == '\0')
        {
        return -2;                              // there needs to be at least one good 
        }                                       // digit before terminating string
    
    unsigned long abs_bin = 0;
    while (i <= 64 && dec[i] != '\0')
        {
        if ( dec[i] >= '0' && dec[i] <= '9' )
            {
            if (abs_bin > 214748364)
                {
                return -1;                                // this is going to be too big
                }
            abs_bin *= 10;                                // previous value gets bumped to the left one digit...                
            abs_bin += (unsigned long)(dec[i] - '0');     // ... and a new digit appended to the right
            i++;
            }
         else
            {
            return -2;                                    // not a legit digit in text string
            }
        }
    
    if (dec[i] != '\0')
        {
        return -2;                                // not terminated string in 64 chars
        }
    
    if (negative)
        {
        if (abs_bin > 2147483648)
            {
            return -1;                            // too big
            }
        *bin = -(long)abs_bin;
        }
     else
        {
        if (abs_bin > 2147483647)
            {
            return -1;                            // too big
            }
        *bin = (long)abs_bin;
        }
    
    return 0;
    }


void binary_to_decimal(char *dec, long bin)
    {
    unsigned long long acc;                // 64-bit unsigned integer
    
    if (bin < 0)
        {
        *(dec++) = '-';                    // leading minus sign
        bin = -bin;                        // make bin value positive
        }
    
    acc = 989312855LL*(unsigned long)bin;        // very nearly 0.2303423488 * 2^32
    acc += 0x00000000FFFFFFFFLL;                 // we need to round up
    acc >>= 32;
    acc += 57646075LL*(unsigned long)bin;
    // (2^59)/(10^10)  =  57646075.2303423488  =  57646075 + (989312854.979825)/(2^32)  
    
    int past_leading_zeros = 0;
    for (int i=9; i>=0; i--)            // maximum number of digits is 10
        {
        acc <<= 1;
        acc += (acc<<2);                // an efficient way to multiply a long long by 10
//      acc *= 10;
        
        unsigned int digit = (unsigned int)(acc >> 59);        // the digit we want is in bits 59 - 62
        
        if (digit > 0)
            {
            past_leading_zeros = 1;
            }
        
        if (past_leading_zeros)
            {
            *(dec++) = '0' + digit;
            }
        
        acc &= 0x07FFFFFFFFFFFFFFLL;    // mask off this digit and go on to the next digit
        }
    
    if (!past_leading_zeros)            // if all digits are zero ...
        {
        *(dec++) = '0';                 // ... put in at least one zero digit
        }
    
    *dec = '\0';                        // terminate string
    }


#if 1

#include <stdlib.h>
#include <stdio.h>
int main (int argc, const char* argv[])
    {
    char dec[64];
    long bin, result1, result2;
    unsigned long num_errors;
    long long long_long_bin;
    
    num_errors = 0;
    for (long_long_bin=-2147483648LL; long_long_bin<=2147483647LL; long_long_bin++)
        {
        bin = (long)long_long_bin;
        if ((bin&0x00FFFFFFL) == 0)
            {
            printf("bin = %ld \n", bin);        // this is to tell us that things are moving along
            }
        binary_to_decimal(dec, bin);
        decimal_to_binary(dec, &result1);
        sscanf(dec, "%ld", &result2);            // decimal_to_binary() should do the same as this sscanf()
        
        if (bin != result1 || bin != result2)
            {
            num_errors++;
            printf("bin = %ld, result1 = %ld, result2 = %ld, num_errors = %ld, dec = %s \n",
                bin, result1, result2, num_errors, dec);
            }
        }
    
    printf("num_errors = %ld \n", num_errors);
    
    return 0;
    }

#else

#include <stdlib.h>
#include <stdio.h>
int main (int argc, const char* argv[])
    {
    char dec[64];
    long bin;
    
    printf("bin = ");
    scanf("%ld", &bin);
    while (bin != 0)
        {
        binary_to_decimal(dec, bin);
        printf("dec = %s \n", dec);
        printf("bin = ");
        scanf("%ld", &bin);
        }
    
    return 0;
    }

#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

void Decimal2Binary(long value,char *b,int len)
{
    if(value>0)
    {
        do
        {
            if(value==1)
            {
                *(b+len-1)='1';
                break;
            }
            else
            {
                *(b+len-1)=(value%2)+48;
                value=value/2;
                len--;
            }
        }while(1);
    }
}
long Binary2Decimal(char *b,int len)
{
    int i=0;
    int j=0;
    long value=0;
    for(i=(len-1);i>=0;i--)
    {
        if(*(b+i)==49)
        {
            value+=pow(2,j);
        }
        j++;
    }
    return value;
}
int main()
{
    char data[11];//最後一個BIT要拿來當字串結尾
    long value=1023;
    memset(data,'0',sizeof(data));
    data[10]='\0';//字串結尾
    Decimal2Binary(value,data,10);
    printf("%d->%s\n",value,data);
    value=Binary2Decimal(data,10);
    printf("%s->%d",data,value);
    return 0;
}