快速将二进制字节数组转换为十进制字符串的C语言实现方法

你的核心问题是无法用常规数据类型存储整个超大数值，导致累加溢出，而逐位乘的方法效率太低。下面直接给你解决思路和可运行的C代码，同时解释关键细节。

现有代码的问题 #

你写的asDecString用signed int存储累加值，只要字节数组长度超过4（32位int的字节数）就会溢出，而且当i*8超过int的位宽时，移位操作是未定义行为，完全无法处理大数。

高效解决方案：大整数除法取余 #

核心思路是模拟人工转十进制的过程：把二进制大整数不断除以10，收集余数（余数就是十进制的低位），直到商为0，最后反转余数得到完整的十进制字符串。这个方法的循环次数等于十进制数的位数，远少于逐位乘的二进制位数循环，效率更高。

完整实现代码 #

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

typedef unsigned char byte;

typedef struct Bin {
    int size;
    byte *ptrToVal;
} Bin;

// 辅助函数：小端字节数组表示的大整数除以10，返回余数，同时更新bin为商（自动移除前导零）
unsigned char big_div10(Bin *bin) {
    unsigned long long carry = 0;
    int new_size = 0;
    // 从最高位字节开始处理（小端存储，所以从size-1到0遍历）
    for (int i = bin->size - 1; i >= 0; i--) {
        unsigned long long current = carry * 256 + bin->ptrToVal[i];
        bin->ptrToVal[i] = (byte)(current / 10);
        carry = current % 10;
        // 记录最后一个非零字节的位置，用来更新商的有效长度
        if (bin->ptrToVal[i] != 0) {
            new_size = i + 1;
        }
    }
    bin->size = new_size;
    return (unsigned char)carry;
}

void asDecString(Bin* this) {
    // 处理空数组或全零的边界情况
    if (this->size == 0) {
        printf("0\n");
        return;
    }
    int is_zero = 1;
    for (int i = 0; i < this->size; i++) {
        if (this->ptrToVal[i] != 0) {
            is_zero = 0;
            break;
        }
    }
    if (is_zero) {
        printf("0\n");
        return;
    }

    // 预分配足够的空间存储十进制数字（最多为字节数*3，足够覆盖所有情况）
    int max_digits = this->size * 3;
    byte *digits = (byte*)malloc(max_digits * sizeof(byte));
    if (digits == NULL) {
        perror("malloc failed");
        return;
    }

    // 复制原数组，避免修改输入的原始数据
    Bin temp_bin = *this;
    byte *temp_ptr = (byte*)malloc(temp_bin.size * sizeof(byte));
    if (temp_ptr == NULL) {
        perror("malloc failed");
        free(digits);
        return;
    }
    memcpy(temp_ptr, temp_bin.ptrToVal, temp_bin.size);
    temp_bin.ptrToVal = temp_ptr;

    // 循环除以10，收集余数
    int digit_count = 0;
    while (temp_bin.size > 0) {
        unsigned char rem = big_div10(&temp_bin);
        digits[digit_count++] = rem;
    }

    // 反转余数数组，输出十进制字符串
    printf("十进制结果：");
    for (int i = digit_count - 1; i >= 0; i--) {
        printf("%c", digits[i] + '0');
    }
    printf("\n");

    // 释放分配的内存，避免泄漏
    free(temp_ptr);
    free(digits);
}

// 测试用例：存储的是0x12345678（小端存储，所以数组顺序是0x78,0x56,0x34,0x12）
int main() {
    byte val[] = {0x78, 0x56, 0x34, 0x12};
    Bin bin = {4, val};
    asDecString(&bin); // 输出：305419896
    return 0;
}

关键细节说明 #

1. 字节序适配：代码默认你的Bin结构是小端存储（ptrToVal[0]是数值的最低8位），如果你的数组是大端（ptrToVal[0]是最高位），只需要把big_div10里的循环顺序改成从0到size-1即可。
2. 避免溢出：用unsigned long long处理中间计算，因为256*9+255=2559（carry最大为9，byte最大为255），远小于unsigned long long的最大值，不会溢出。
3. 内存管理：C语言需要手动释放分配的内存，代码里已经处理了malloc失败和内存释放的逻辑。
4. 效率优势：循环次数等于十进制数的位数，比如100字节的二进制数，十进制位数约241位，循环241次即可完成，远快于逐位乘的800次循环。

内容的提问来源于stack exchange，提问作者xtay2