在C语言中实现长比特串到十六进制字符串的高效转换

嘿，这个问题我太熟了——用strtoll这类整数转换函数确实会卡在长度限制上，毕竟哪怕是64位的long long最多也就处理64位二进制，超过之后直接溢出，根本没法得到正确结果。其实我们完全可以绕开整数类型，直接通过二进制分组转十六进制的方式来处理，不管你的密钥有多长都能搞定，效率还很高。

核心思路 #

十六进制的每一位对应4位二进制数（比如0xF对应1111），所以我们可以直接把超长二进制串按每4位一组拆分，每组转换成对应的十六进制字符即可。如果二进制串的长度不是4的倍数，只需要在开头补0凑齐分组就行（当然你也可以选择在末尾补，取决于你的需求，但通常开头补0更符合十六进制的对齐习惯）。

具体实现（C语言） #

下面是一个高效的实现示例，纯字符串处理，没有任何长度限制（只要内存足够）：

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

// 将二进制字符串转换为十六进制字符串，返回的内存需要调用者手动free
unsigned char* bin_to_hex(const unsigned char* bin_str) {
    if (!bin_str || !*bin_str) return NULL;

    size_t bin_len = strlen((const char*)bin_str);
    // 计算十六进制字符串长度：向上取整(bin_len/4) + 1（存储终止符'\0'）
    size_t hex_len = (bin_len + 3) / 4 + 1;
    unsigned char* hex_str = (unsigned char*)malloc(hex_len);
    if (!hex_str) return NULL;

    // 计算需要补的前导0数量，让总长度是4的倍数
    size_t pad_bits = (4 - (bin_len % 4)) % 4;
    size_t hex_idx = 0;
    unsigned char current_nibble = 0;

    // 先处理补的前导0
    for (size_t i = 0; i < pad_bits; i++) {
        current_nibble = (current_nibble << 1) | 0;
    }

    // 遍历二进制串的每一位
    for (size_t i = 0; i < bin_len; i++) {
        // 校验输入是否为合法二进制字符
        if (!isdigit(bin_str[i]) || (bin_str[i] != '0' && bin_str[i] != '1')) {
            free(hex_str);
            return NULL;
        }

        // 将当前二进制位加入到当前4位组中
        current_nibble = (current_nibble << 1) | (bin_str[i] - '0');

        // 每凑够4位，转换为一个十六进制字符
        if ((pad_bits + i + 1) % 4 == 0) {
            hex_str[hex_idx++] = (current_nibble < 10) 
                ? (current_nibble + '0') 
                : (current_nibble - 10 + 'A'); // 要小写的话换成'a'
            current_nibble = 0;
        }
    }

    // 处理最后不足4位的情况（理论上pad_bits处理后不会出现，但留个保险）
    if ((pad_bits + bin_len) % 4 != 0) {
        hex_str[hex_idx++] = (current_nibble < 10) 
            ? (current_nibble + '0') 
            : (current_nibble - 10 + 'A');
    }

    // 添加字符串终止符
    hex_str[hex_idx] = '\0';
    return hex_str;
}

// 测试示例
int main() {
    unsigned char* key = "0111010111010101010101010100101011010";
    unsigned char* hex_result = bin_to_hex(key);
    if (hex_result) {
        printf("转换后的十六进制字符串：%s\n", hex_result);
        free(hex_result); // 记得释放内存
    } else {
        printf("输入的二进制字符串不合法！\n");
    }
    return 0;
}

这个方法的优势 #

• 无长度限制：不管你的二进制串是50位、60位还是几百位，都能轻松处理，完全不依赖整数类型的存储上限。
• 高效：时间复杂度是O(n)（n为二进制串长度），纯内存操作，没有额外的复杂计算。
• 灵活：可以轻松修改成输出小写十六进制（把代码中的'A'换成'a'即可），或者调整补0的位置（比如从末尾补）。

注意事项 #

• 函数返回的十六进制字符串是用malloc分配的，调用者一定要记得用free释放，避免内存泄漏。
• 代码中加入了输入合法性校验，如果你的二进制串来源绝对可靠，可以去掉这部分逻辑提升一点效率。

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