如何在C++中将大型bitset<256>转换为十六进制？

我有一个bitset<256>类型的大型位集，想要将其转换为十六进制字符串，但使用常规的to_ulong()和to_ullong()方法会抛出溢出错误。

我尝试的代码如下：

bitset<256> bitresult = to_bitset(hexToBinary(x2)) ^ to_bitset(hexToBinary(random[i-1]));
stringstream res;

bitset<64> b1;
bitset<64> b2;
bitset<64> b3;
bitset<64> b4;

for (int i1=0; i1<64; i1++)
b1[i1]=bitresult[i1];
for (int i1=0; i1<64; i1++)
b2[i1]=bitresult[i1+64];
for (int i1=0; i1<64; i1++)
b3[i1]=bitresult[i1+128];
for (int i1=0; i1<64; i1++)
b4[i1]=bitresult[i1+192];

res<< hex << b1.to_ullong();
res<< hex << b2.to_ullong();
res<< hex << b3.to_ullong();
res<< hex << b4.to_ullong();
string hashresult = res.str();
cout << hashresult <<endl;
return sha256(hashresult);

但拆分后使用to_ullong()仍会抛出溢出错误，我认为当前方案存在缺陷，请问是否有更优的解决方案？

方法一：逐位分组转换为十六进制 #

直接遍历bitset<256>的每一位，每4位一组转换为对应的十六进制字符，完全绕开数值转换，从根源上避免溢出：

#include <bitset>
#include <string>

std::string bitset256_to_hex(const std::bitset<256>& bs) {
    const char hex_chars[] = "0123456789abcdef";
    std::string result;
    // 从最高位到最低位处理，每4位为一个十六进制字符
    for (int i = 255; i >= 0; i -= 4) {
        int val = 0;
        // 提取当前4位的数值
        for (int j = 0; j < 4; ++j) {
            if (i - j >= 0 && bs[i - j]) {
                val |= (1 << j);
            }
        }
        result += hex_chars[val];
    }
    return result;
}

替换原代码中的字符串流逻辑即可：

std::string hashresult = bitset256_to_hex(bitresult);
std::cout << hashresult << std::endl;
return sha256(hashresult);

方法二：转换为字节数组再生成十六进制 #

先将bitset<256>映射为32字节的数组，再将每个字节转换为两位十六进制字符，逻辑更贴近底层存储：

#include <bitset>
#include <string>
#include <sstream>
#include <iomanip>

std::string bitset256_to_hex(const std::bitset<256>& bs) {
    unsigned char bytes[32] = {0};
    // 将位集的每一位映射到对应字节的对应位
    for (int i = 0; i < 256; ++i) {
        if (bs[i]) {
            bytes[i / 8] |= (1 << (i % 8));
        }
    }
    // 字节数组转十六进制字符串（大端序输出，高位字节在前）
    std::stringstream res;
    res << std::hex << std::setfill('0');
    for (int i = 31; i >= 0; --i) {
        res << std::setw(2) << static_cast<unsigned int>(bytes[i]);
    }
    return res.str();
}

原方案出错原因 #

你拆分后仍溢出的核心问题是：to_ullong()的实现会检查位集表示的数值是否能被unsigned long long容纳，当64位bitset的最高位（第63位）为1时，部分编译器的边界检查逻辑会误判为溢出（尽管从数值上看这属于unsigned long long的合法范围）。上面两种方法直接操作位而非转换为数值，完全避免了这个问题。

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