C ++ - Chuyển đổi từ thập phân sang nhị phân

Tôi đã viết một chương trình 'đơn giản' (tôi mất 30 phút) để chuyển đổi số thập phân sang nhị phân. Tôi CHẮC CHẮN là có rất nhiều cách đơn giản hơn nên bạn có thể chỉ cho tôi được không? Đây là mã:

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

Nhân tiện nó phức tạp nhưng tôi đã cố gắng hết sức.

chỉnh sửa - Đây là giải pháp tôi đã sử dụng:

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

std::bitsetcó một .to_string()phương thức trả về một std::stringbiểu diễn văn bản đang giữ ở dạng nhị phân, với phần đệm bằng 0 ở đầu.

Chọn chiều rộng của tập std::bitset<32>bit nếu cần cho dữ liệu của bạn, ví dụ: để lấy chuỗi 32 ký tự từ số nguyên 32 bit.

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

CHỈNH SỬA: Vui lòng không chỉnh sửa câu trả lời của tôi cho Hệ bát phân và Hệ thập lục phân. OP đã yêu cầu cụ thể cho Decimal To Binary.

Sau đây là một hàm đệ quy nhận một số nguyên dương và in các chữ số nhị phân của nó ra bảng điều khiển.

Alex gợi ý, để hiệu quả, bạn có thể xóa printf()và lưu kết quả trong bộ nhớ ... tùy thuộc vào phương pháp lưu trữ, kết quả có thể bị đảo ngược.

/**
 * 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);
}

Tín dụng cho UoA ENGGEN 131

* Lưu ý: Lợi ích của việc sử dụng int không dấu là nó không được âm.

Bạn có thể sử dụng std :: bitset để chuyển đổi một số sang định dạng nhị phân của nó.

Sử dụng đoạn mã sau:

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

Tôi đã tìm thấy điều này trên chính stackoverflow. Tôi đang đính kèm liên kết .

Một giải pháp khá đơn giản để in tệp nhị phân:

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

Giải pháp không đệ quy:

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

Giải pháp đệ quy:

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

Đây là hai cách tiếp cận. Một trong những tương tự như cách tiếp cận của bạn

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

và cái kia sử dụng std :: bitset như những người khác đề xuất.

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

Một intbiến không ở dạng thập phân mà ở dạng nhị phân. Những gì bạn đang tìm kiếm là biểu diễn chuỗi nhị phân của số, bạn có thể nhận được bằng cách áp dụng mặt nạ lọc các bit riêng lẻ, sau đó in chúng:

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

Đó là giải pháp nếu câu hỏi của bạn là thuật toán. Nếu không, bạn nên sử dụng lớp std :: bitset để xử lý điều này cho bạn:

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

Việc chuyển đổi từ số tự nhiên sang chuỗi nhị phân:

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

Đây là biến thể hiện đại có thể được sử dụng cho intscác kích cỡ khác nhau.

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

Bạn muốn làm điều gì đó như:

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

DECIMAL TO BINARY NO ARRAYS ĐƯỢC SỬ DỤNG * do Oya thực hiện:

Tôi vẫn là người mới bắt đầu, vì vậy mã này sẽ chỉ sử dụng các vòng lặp và biến xD ...

Hy vọng bạn thích nó. Điều này có thể được thực hiện đơn giản hơn nó ...

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

đây là một công cụ chuyển đổi đơn giản bằng cách sử dụng std::stringlàm vùng chứa. nó cho phép một giá trị âm.

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

Đây là một chương trình đơn giản hơn bao giờ hết

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

Trên thực tế, có một cách rất đơn giản để làm như vậy. Những gì chúng tôi làm là sử dụng một hàm đệ quy được cung cấp số (int) trong tham số. Nó khá dễ hiểu. Bạn cũng có thể thêm các điều kiện / biến thể khác. Đây là mã:

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

tham khảo: - https://www.geeksforgeeks.org/program-decimal-binary-conversion/

hoặc sử dụng hàm: -

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

int main()
{

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


}

hoặc sử dụng dịch chuyển trái

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


}

Đối với điều này, trong C ++ bạn có thể sử dụng hàm itoa (). Hàm này chuyển đổi bất kỳ số nguyên thập phân nào thành số nhị phân, thập phân, thập lục phân và số bát phân.

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

Tuy nhiên, nó chỉ được hỗ trợ bởi các trình biên dịch cụ thể.

Bạn có thể xem thêm: itoa - Tham khảo 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 rồi .. Tôi có thể hơi mới đối với C ++, nhưng tôi cảm thấy các ví dụ trên không hoàn toàn hoàn thành công việc.

Đây là lý do của tôi về tình huống này.

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 = Giá trị chúng tôi đang kiểm tra.

@bit_pre precision = Bit cao nhất bên trái để kiểm tra.

@Length = Kích thước khối Byte tối đa. Ví dụ: 7 = 1 Byte và 9 = 2 Byte, nhưng chúng tôi biểu diễn điều này dưới dạng bit nên 1 Byte = 8 Bit.

@binary = chỉ là một cái tên ngu ngốc nào đó mà tôi đã đặt để gọi mảng ký tự mà chúng ta đang đặt. Chúng tôi đặt điều này thành tĩnh để nó sẽ không được tạo lại với mọi cuộc gọi. Đối với việc chỉ nhận một kết quả và hiển thị nó thì điều này hoạt động tốt, nhưng nếu giả sử bạn muốn hiển thị nhiều kết quả trên một giao diện người dùng, tất cả chúng sẽ hiển thị dưới dạng kết quả cuối cùng. Điều này có thể được khắc phục bằng cách loại bỏ tĩnh, nhưng hãy đảm bảo rằng bạn xóa [] kết quả khi hoàn tất.

@begin = Đây là chỉ số thấp nhất mà chúng tôi đang kiểm tra. Mọi thứ vượt quá điểm này đều bị bỏ qua. Hoặc như thể hiện trong vòng lặp thứ 2 được đặt thành 0.

@first loop - Ở đây chúng tôi đặt giá trị thành 48 và về cơ bản thêm 0 hoặc 1 thành 48 dựa trên giá trị bool của (value & bit_value) == bit_value. Nếu điều này là đúng, char được đặt thành 49. Nếu điều này là sai, char được đặt thành 48. Sau đó, chúng tôi chuyển bit_value hoặc về cơ bản nhân nó với 2.

@second loop - Ở đây chúng tôi đặt tất cả các chỉ mục mà chúng tôi đã bỏ qua thành 48 hoặc '0'.

MỘT SỐ VÍ DỤ ĐẦU RA !!!

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.

KIỂM TRA TỐC ĐỘ

Câu trả lời của Câu hỏi gốc: "Phương thức: toBinary (int);"

Số lần thực thi: 10.000, Tổng thời gian (Milli): 4701.15, Thời gian trung bình (Nano giây): 470114

Phiên bản của tôi: "Phương thức: DecimalToBinary (int, int);"

// Sử dụng độ chính xác 64 bit.

Số lần thực thi: 10.000.000, Tổng thời gian (Milli): 3386, Thời gian trung bình (Nano giây): 338

// Sử dụng độ chính xác 1 bit.

Số lần thực thi: 10.000.000, Tổng thời gian (Milli): 634, Thời gian trung bình (Nano giây): 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;
}

đây là một cách đơn giản để lấy dạng nhị phân của một int. tín dụng cho learningncpp.com. Tôi chắc chắn rằng điều này có thể được sử dụng theo nhiều cách khác nhau để đi đến cùng một điểm.

Trong cách tiếp cận này, số thập phân sẽ được chuyển đổi thành số nhị phân tương ứng trong chuỗi định dạng. Kiểu trả về chuỗi được chọn vì nó có thể xử lý nhiều phạm vi giá trị đầu vào hơn.

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ách chuyển đổi thập phân sang nhị phân của tôi trong C ++. Nhưng vì chúng ta đang sử dụng mod, hàm này sẽ hoạt động trong trường hợp hệ thập lục phân hoặc bát phân. Bạn cũng có thể chỉ định các bit. Hàm này tiếp tục tính toán bit có ý nghĩa thấp nhất và đặt nó ở cuối chuỗi. Nếu bạn không giống với phương pháp này hơn bạn có thể truy cập: 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;
}

Đầu ra:

0
01
010
0100
01111
011110
0111101
01111111

Giải pháp của bạn cần sửa đổi. Chuỗi cuối cùng phải được đảo ngược trước khi trả về:

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

sử dụng bitmask và bitwise và.

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

Dưới đây là mã C đơn giản chuyển đổi nhị phân sang thập phân và ngược lại. Tôi đã viết nó từ lâu cho một dự án, trong đó mục tiêu là một bộ xử lý nhúng và các công cụ phát triển có một stdlib đó là cách quá lớn đối với ROM firmware.

Đây là mã C chung chung không sử dụng bất kỳ thư viện nào, cũng không sử dụng phép chia hoặc toán tử phần còn lại (%) (chậm trên một số bộ xử lý nhúng), cũng không sử dụng bất kỳ dấu chấm động nào, cũng không sử dụng bất kỳ tra cứu bảng nào. giả lập bất kỳ số học BCD. Những gì nó sử dụng là loại long long, cụ thể hơn unsigned long long(hoặc uint64_t), vì vậy nếu bộ xử lý nhúng của bạn (và trình biên dịch C đi kèm với nó) không thể thực hiện số học số nguyên 64-bit, thì mã này không dành cho ứng dụng của bạn. Nếu không, tôi nghĩ đây là mã C chất lượng sản xuất (có thể sau khi đổi longthành int32_tvà unsigned long longthành uint64_t). Tôi đã chạy điều này qua đêm để kiểm tra nó cho mọi giá trị số nguyên có dấu 2³² và không có lỗi khi chuyển đổi theo cả hai hướng.

Chúng tôi đã có một trình biên dịch / liên kết C có thể tạo các tệp thực thi và chúng tôi cần làm những gì chúng tôi có thể làm mà không cần bất kỳ stdlib nào (đó là một con lợn). Vì vậy, không printf()cũng không scanf(). Thậm chí sprintf()không phải cũng không sscanf(). Nhưng chúng tôi vẫn có giao diện người dùng và phải chuyển đổi các số cơ số 10 thành nhị phân và ngược lại. (Chúng tôi cũng đã tạo ra malloc()tiện ích giống như của riêng mình và các hàm toán học siêu việt của riêng chúng tôi.)

Vì vậy, đây là cách tôi đã làm điều đó ( mainchương trình và các cuộc gọi đến stdlib ở đó để kiểm tra điều này trên máy mac của tôi, không phải cho mã nhúng). Ngoài ra, bởi vì một số hệ thống nhà phát triển cũ hơn không nhận dạng được " int64_t" và " uint64_t" và các kiểu tương tự, các kiểu long longvà unsigned long longđược sử dụng và giả định là giống nhau. Và longđược giả định là 32 bit. Tôi đoán tôi có thể đã chỉnh sửa typedefnó.

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