通过 <bitset> 和 HEX

如何解决通过 <bitset> 和 HEX

我正在尝试使用类构建一个简单的 BIN -> HEX 转换器，我想稍后将其保存在头文件中以供最终需要 <. .>

有点管用。有点因为我有一些输出，但我无法理解打印 X 时发生了什么。为什么我会收到其他异常？我应该只得到 4 位组合..

我正在努力学习。很抱歉最终出现了愚蠢的代码。

#include <iostream>
#include <bitset>

class Hash{
private:
    char stringa[150];
    int byteCount=0;

public:

//call to get a string
void getStringa(){

    char temp_char;
    std::cout << "Write a string and press enter to continue" << std::endl;
    for(unsigned int i = 0; i < 150; i++){
        temp_char = std::cin.get();
        if(temp_char == '\n'){
            stringa[i] = '\0';
            byteCount = i;
            break;
        }
        stringa[i] = temp_char;
    }
}

char nibbletoHEX(std::bitset<4> x){
    char HEX;

    if(x == 0000) return HEX = '0';
    else if (x == 0001) return HEX = '1';
    else if (x == 0010) return HEX = '2';
    else if (x == 0011) return HEX = '3';
    else if (x == 0100) return HEX = '4';
    else if (x == 0101) return HEX = '5';
    else if (x == 0110) return HEX = '6';
    else if (x == 0111) return HEX = '7';
    else if (x == 1000) return HEX = '8';
    else if (x == 1001) return HEX = '9';
    else if (x == 1010) return HEX = 'A';
    else if (x == 1011) return HEX = 'B';
    else if (x == 1100) return HEX = 'C';
    else if (x == 1101) return HEX = 'D';
    else if (x == 1110) return HEX = 'E';
    else if (x == 1111) return HEX = 'F';

    else return 'X';
}

//call to encode string to 256 binary digits and then go HEX a nibble at a time

void encodeStringa(){
    std::cout << "converting  |" << stringa << "|  to binary: \n";
    char HEXSTRINGA[64];

    for(unsigned int i = 0; i < 150; i++){
        if(stringa[i] == '\0') break;
        std::bitset<4> x(stringa[i]);
        std::cout << x;

        HEXSTRINGA[i] = nibbletoHEX(x);


    }

    std::cout << std::endl;
    std::cout << "You used " << byteCount << " bytes.\n";
    std::cout << "You still have " << 64-byteCount << " bytes." << std::endl;

    std::cout << "Converted string in HEX form: " << HEXSTRINGA << std::endl;

}


};

int main() {

    Hash BCHAIN;

    BCHAIN.getStringa();
    BCHAIN.encodeStringa();


    return 0;
 }

一些测试 IO 是：

**Teststring**
0100010100110100001101000010100111100111
XXBXBXA3XF

X 至少对于我正在尝试做的事情来说是一个错误.. 我不明白为什么，我希望某些字符的 4 位随机组合......因为我只有 15 种 4 位组合。不是 X ... 是溢出问题吗？

解决方法

你在nibbleToHEX中写的数字不是二进制而是十进制（不以零开头）和八进制（以零开头）

如果你想使用二进制字符串，你应该使用std::bitset：

#include <string>

char nibbleToHEX(std::bitset<4> x){
    char HEX;

    if(x == std::bitset<4>(std::string("0000"))) return HEX = '0';
    else if (x == std::bitset<4>(std::string("0001"))) return HEX = '1';
    else if (x == std::bitset<4>(std::string("0010"))) return HEX = '2';
    else if (x == std::bitset<4>(std::string("0011"))) return HEX = '3';
    else if (x == std::bitset<4>(std::string("0100"))) return HEX = '4';
    else if (x == std::bitset<4>(std::string("0101"))) return HEX = '5';
    else if (x == std::bitset<4>(std::string("0110"))) return HEX = '6';
    else if (x == std::bitset<4>(std::string("0111"))) return HEX = '7';
    else if (x == std::bitset<4>(std::string("1000"))) return HEX = '8';
    else if (x == std::bitset<4>(std::string("1001"))) return HEX = '9';
    else if (x == std::bitset<4>(std::string("1010"))) return HEX = 'A';
    else if (x == std::bitset<4>(std::string("1011"))) return HEX = 'B';
    else if (x == std::bitset<4>(std::string("1100"))) return HEX = 'C';
    else if (x == std::bitset<4>(std::string("1101"))) return HEX = 'D';
    else if (x == std::bitset<4>(std::string("1110"))) return HEX = 'E';
    else if (x == std::bitset<4>(std::string("1111"))) return HEX = 'F';

    else return 'X';
}

或 0b 前缀（C++14 起）：

char nibbleToHEX(std::bitset<4> x){
    char HEX;

    if(x == 0b0000) return HEX = '0';
    else if (x == 0b0001) return HEX = '1';
    else if (x == 0b0010) return HEX = '2';
    else if (x == 0b0011) return HEX = '3';
    else if (x == 0b0100) return HEX = '4';
    else if (x == 0b0101) return HEX = '5';
    else if (x == 0b0110) return HEX = '6';
    else if (x == 0b0111) return HEX = '7';
    else if (x == 0b1000) return HEX = '8';
    else if (x == 0b1001) return HEX = '9';
    else if (x == 0b1010) return HEX = 'A';
    else if (x == 0b1011) return HEX = 'B';
    else if (x == 0b1100) return HEX = 'C';
    else if (x == 0b1101) return HEX = 'D';
    else if (x == 0b1110) return HEX = 'E';
    else if (x == 0b1111) return HEX = 'F';

    else return 'X';
}

我的建议是使用数组（字符串文字是数组）：

char nibbleToHEX(std::bitset<4> x){
    unsigned long idx = x.to_ulong();
    if (idx < 16) {
        return "0123456789ABCDEF"[idx];
    } else {
        return 'X';
    }
}

另外你应该在函数HEXSTRINGA中初始化encodeStringa，否则可能会在hash后打印一些垃圾：

    char HEXSTRINGA[64] = "";

,

只需将四个后续字符组合成一个数字，您就可以做得更简单：

char const* const digits = "0123456789abcdefg"; // or upper case,if you prefer

for(auto i = x; i < byteCount; i += 4)
//           ^: to be considered later!
{
    unsigned int n
        = (stringa[i + 0] == '1') << 3
        | (stringa[i + 1] == '1') << 2
        | (stringa[i + 2] == '1') << 1
        | (stringa[i + 3] == '1') << 0;

    HEXSTRING[pos++] = digits[n];
}

到目前为止，我没有考虑过一个字母既不是'0'也不是'1'——把这个留给你！

尚未公开的一件事是输入数字的数量不是是 4 的倍数！

好吧，上面我从一些未指定的 x 开始，还记得吗？我更喜欢用前导零填充缺少的数字，即考虑例如110011 为 00110011：

size_t pos = 0;
unsigned int n = 0;
size_t offset = byteCount % 4;
if(offset != 0)
{
    size_t o = offset - 1
    for(size_t i = 0; i <= o; ++i)
    {
        n |= (stringa[i] == '1') << (o - i);
    }
    HEX_STRING[pos++] = digits[n];
}

现在我们从这个偏移量开始上面的循环：

for(auto i = offset; i < byteCount; i += 4)
{
    // ...
}

为了使其正常工作，您还需要适当地设置 byteCount。如果字符串短于 150 个字符，则执行此操作。您可以在进入循环之前将其设置为 150 – 但是，如果输入字符串更长怎么办？你会得到不适当的结果！

您可能更喜欢读std::string！

std::string stringa;
std::cin >> stringa;

这将在出现的第一个空格处停止读取字符串。如果您还想处理 00 11 之类的输入，您可以改用 std::getline（您可以使用当前的解决方案这样做，但不要跳过空格）。

无论采用哪种方法，您都可以使用 stringa.length() 而不是 byteCount，后者被完全删除。