Question

我正在使用此代码将二进制转换为十进制。但是这个代码不适用于更多的64位，因为__int64只保存8个字节。你能告诉我一个用于将超过64位转换成十进制值的算法吗？我的最终结果也必须是字符串。感谢帮助。感谢。

 int bin2dec(char *bin)
 {
    __int64  b, k, m, n;
    __int64  len, sum = 0;

    len = strlen(bin) - 1;
    for(k = 0; k <= len; k++)
    {
            n = (bin[k] - '0'); // char to numeric value
            if ((n > 1) || (n < 0))
            {
                    puts("\n\n ERROR! BINARY has only 1 and 0!\n");
                    return (0);
            }
            for(b = 1, m = len; m > k; m--)
            {
                    // 1 2 4 8 16 32 64 ... place-values, reversed here
                    b *= 2;
            }
            // sum it up
            sum = sum + n * b;
    }
    return(sum);
 }

Answer 1

通常，当处理的数据大于您在一个整数单元中存储的数据时，解决方案是以下两种方法之一：

使用字符数组/字符串将值存储为“ASCII”（每个字符为一位）
使用数组中的多个整数来存储值，每个元素使用X位。

转换没有什么特别不同，只要你完成X位，就转移到下一个元素。

顺便说一下：

int bin2dec(char *bin)
 {
    int  k, n;
    int len;
    __int64  sum = 0;

    len = strlen(bin);
    for(k = 0; k < len; k++)
    {
            n = (bin[k] - '0'); // char to numeric value
            if ((n > 1) || (n < 0))
            {
                    puts("\n\n ERROR! BINARY has only 1 and 0!\n");
                    return (0);
            }
            // sum it up
            sum <<= 1;
            sub += n;
    }
    return(sum);
 }

有点简单。

Answer 2

算法很简单：保持除以10的幂，以获得值的每个10位。诀窍是能够存储和除以大于64位的数字的10的幂。存储大数字的算法存在，你应该找到一个，虽然它们并不难，但它们比在Stackoverflow上输入答案更合适。

但基本上，你创建一个累加器bignum，将其设置为1并开始将其乘以10，直到它的值大于目标bignum。然后你将它除以10并启动算法：

while accum >= 1
divide source/accum place the dividend in your output string. 
substract that number time accum from your source.
divide accum by 10 and loop

你认识那个算法吗？这可能是你被教导如何在小学做长期分工。好吧，这就是你＆＃34; print＆＃34;十进制的二进制数。

有很多方法可以改善这种性能。（提示，你不必在base 10中工作。在基数10 ^ 8中为32位整数工作或在10 ^ 17下为64位整数工作。）但首先你需要一个将减去的库，添加，多重，划分和比较bignums。

当然，bignum库可能已经有了toString函数。

Answer 3

您可以随时将大数字（在任何基数中）存储为std::deque数字 - 使用双端队列可以轻松地在任一端添加数字。您可以对它们实现基本的算术运算，这样可以使用标准乘法和加数字算法轻松地将二进制转换为十进制：

std::deque<char> &operator *=(std::deque<char> &a, unsigned b)
{
    unsigned carry = 0;
    for (auto d = a.rbegin(); d != a.rend(); d++) {
        carry += (*d - '0') * b;
        *d = (carry % 10) + '0';
        carry /= 10; }
    while (carry > 0) {
        a.push_front((carry % 10) + '0');
        carry /= 10; }
    return a;
}

std::deque<char> &operator +=(std::deque<char> &a, unsigned b)
{
    for (auto d = a.rbegin(); b > 0 && d != a.rend(); d++) {
        b += (*d - '0');
        *d = (b % 10) + '0';
        b /= 10; }
    while (b > 0) {
        a.push_front((b % 10) + '0');
        b /= 10; }
    return a;
}

std::string bin2dec(char *bin) {
    std::deque<char> tmp{'0'};
    while (*bin) {
        if (*bin != '0' && *bin != '1') {
            puts("\n\n ERROR! BINARY has only 1 and 0!\n");
            return ""; }
        tmp *= 2;
        if (*bin++ == '1')
            tmp += 1; }
    return std::string(tmp.begin(), tmp.end());
}

Answer 4

手动：

int binaryToDec(char *bin)
 {
    int  k, n;
    int len=strlen(bin);
    int  dec = 0;

    for(k = 0; k < len; k++)
    {
            n = (bin[k] - '0');
            dec <<= 1;
            dec += n;
    }
    return(dec);
 }

你也可以考虑一下bitset：

std::bitset<64> input(*bin);
std::cout<<input.u_long();

对于大于64位的位值，C ++将二进制转换为十进制

4 个答案: