C++实现二进制字符串与十六进制字符串相互转换_C/C++

以下是一个将二进制字符串转换为十六进制字符串的c++函数：

#include <string>
#include <unordered_map>

std::string binarytohex(const std::string& binarystr) {
    // 预定义的二进制到十六进制映射
    std::unordered_map<std::string, char> bintohex = {
        {"0000", '0'}, {"0001", '1'}, {"0010", '2'}, {"0011", '3'},
        {"0100", '4'}, {"0101", '5'}, {"0110", '6'}, {"0111", '7'},
        {"1000", '8'}, {"1001", '9'}, {"1010", 'a'}, {"1011", 'b'},
        {"1100", 'c'}, {"1101", 'd'}, {"1110", 'e'}, {"1111", 'f'}
    };
    
    std::string result;
    std::string paddedbinary = binarystr;
    
    // 在二进制字符串前面补0，使其长度成为4的倍数
    int remainder = paddedbinary.length() % 4;
    if (remainder != 0) {
        paddedbinary = std::string(4 - remainder, '0') + paddedbinary;
    }
    
    // 每4位一组进行转换
    for (size_t i = 0; i < paddedbinary.length(); i += 4) {
        std::string group = paddedbinary.substr(i, 4);
        result += bintohex[group];
    }
    
    return result;
}

使用示例：

#include <iostream>

int main() {
    std::string binary1 = "1101";           // 二进制 1101
    std::string binary2 = "101011";         // 二进制 101011
    std::string binary3 = "111100001010";   // 二进制 111100001010
    
    std::cout << binary1 << " -> " << binarytohex(binary1) << std::endl;  // 输出: d
    std::cout << binary2 << " -> " << binarytohex(binary2) << std::endl;  // 输出: 2b
    std::cout << binary3 << " -> " << binarytohex(binary3) << std::endl;  // 输出: f0a
    
    return 0;
}

如果你想要一个更简洁的版本，也可以使用位运算的方法：

#include <string>
#include <sstream>

std::string binarytohexbitwise(const std::string& binarystr) {
    // 先将二进制字符串转换为整数
    unsigned long long decimal = 0;
    for (char c : binarystr) {
        decimal = (decimal << 1) | (c - '0');
    }
    
    // 再将整数转换为十六进制字符串
    std::stringstream ss;
    ss << std::hex << std::uppercase << decimal;
    
    return ss.str();
}

注意事项：

第一个方法使用查表法，适合处理任意长度的二进制字符串
第二个方法使用位运算，更简洁但可能受限于整数类型的最大长度
两个函数都会自动处理前导零的情况
输出使用大写字母（a-f），如果需要小写字母，可以将映射中的字母改为小写

选择哪种方法取决于你的具体需求：

如果需要处理很长的二进制字符串，建议使用第一种方法
如果二进制字符串长度在64位以内，第二种方法更简洁高效

以下是一个将十六进制字符串转换为二进制字符串的c++函数：

#include <string>
#include <unordered_map>

std::string hextobinary(const std::string& hexstr) {
    // 预定义的十六进制到二进制映射
    std::unordered_map<char, std::string> hextobin = {
        {'0', "0000"}, {'1', "0001"}, {'2', "0010"}, {'3', "0011"},
        {'4', "0100"}, {'5', "0101"}, {'6', "0110"}, {'7', "0111"},
        {'8', "1000"}, {'9', "1001"}, {'a', "1010"}, {'b', "1011"},
        {'c', "1100"}, {'d', "1101"}, {'e', "1110"}, {'f', "1111"},
        {'a', "1010"}, {'b', "1011"}, {'c', "1100"}, {'d', "1101"},
        {'e', "1110"}, {'f', "1111"}
    };
    
    std::string result;
    
    for (char c : hexstr) {
        // 跳过空格等无关字符
        if (c == ' ' || c == '\t' || c == '\n') {
            continue;
        }
        
        // 检查是否为有效的十六进制字符
        if (hextobin.find(c) != hextobin.end()) {
            result += hextobin[c];
        } else {
            // 如果遇到无效字符，可以抛出异常或返回空字符串
            throw std::invalid_argument("invalid hexadecimal character: " + std::string(1, c));
            // 或者返回空字符串：return "";
        }
    }
    
    // 移除前导零（可选）
    size_t firstone = result.find_first_not_of('0');
    if (firstone != std::string::npos) {
        result = result.substr(firstone);
    } else {
        // 如果全是零，返回"0"
        result = "0";
    }
    
    return result;
}

使用示例：

#include <iostream>
#include <stdexcept>

int main() {
    try {
        std::string hex1 = "d";      // 十六进制 d
        std::string hex2 = "2b";     // 十六进制 2b
        std::string hex3 = "f0a";    // 十六进制 f0a
        std::string hex4 = "1f";     // 十六进制 1f
        
        std::cout << hex1 << " -> " << hextobinary(hex1) << std::endl;  // 输出: 1101
        std::cout << hex2 << " -> " << hextobinary(hex2) << std::endl;  // 输出: 101011
        std::cout << hex3 << " -> " << hextobinary(hex3) << std::endl;  // 输出: 111100001010
        std::cout << hex4 << " -> " << hextobinary(hex4) << std::endl;  // 输出: 11111
        
        // 测试小写字母
        std::cout << "a" << " -> " << hextobinary("a") << std::endl;    // 输出: 1010
        
    } catch (const std::exception& e) {
        std::cout << "error: " << e.what() << std::endl;
    }
    
    return 0;
}

如果你想要一个不使用异常处理的版本：

#include <string>
#include <unordered_map>

std::string hextobinarysafe(const std::string& hexstr) {
    std::unordered_map<char, std::string> hextobin = {
        {'0', "0000"}, {'1', "0001"}, {'2', "0010"}, {'3', "0011"},
        {'4', "0100"}, {'5', "0101"}, {'6', "0110"}, {'7', "0111"},
        {'8', "1000"}, {'9', "1001"}, {'a', "1010"}, {'b', "1011"},
        {'c', "1100"}, {'d', "1101"}, {'e', "1110"}, {'f', "1111"},
        {'a', "1010"}, {'b', "1011"}, {'c', "1100"}, {'d', "1101"},
        {'e', "1110"}, {'f', "1111"}
    };
    
    std::string result;
    
    for (char c : hexstr) {
        if (c == ' ' || c == '\t' || c == '\n') {
            continue;
        }
        
        auto it = hextobin.find(c);
        if (it != hextobin.end()) {
            result += it->second;
        } else {
            // 遇到无效字符时返回空字符串
            return "";
        }
    }
    
    // 处理全零的情况
    if (result.empty()) {
        return "0";
    }
    
    // 移除前导零
    size_t firstone = result.find_first_not_of('0');
    if (firstone != std::string::npos) {
        result = result.substr(firstone);
    } else {
        result = "0";
    }
    
    return result;
}

函数特点：