字节流与十六进制字符串的相互转化

以下是将字节流（如 uint8_t 数组）转换为十六进制字符串的C++实现：

std::string bytesToHex(const uint8_t* data, size_t len, bool uppercase = true) {
    // 十六进制字符表（可选大写或小写）
    const char* hex_table = uppercase ? 
        "0123456789ABCDEF" : 
        "0123456789abcdef";

    std::string hex_str;
    hex_str.reserve(len * 2); // 预分配空间，每个字节对应2个字符

    for (size_t i = 0; i < len; ++i) {
        uint8_t byte = data[i];
        // 将高4位和低4位分别转换为十六进制字符
        hex_str.push_back(hex_table[(byte >> 4) & 0x0F]); // 高4位
        hex_str.push_back(hex_table[byte & 0x0F]);        // 低4位
    }

    return hex_str;
}

// 重载版本：支持直接传入 std::vector<uint8_t>
std::string bytesToHex(const std::vector<uint8_t>& data, bool uppercase = true) {
    return bytesToHex(data.data(), data.size(), uppercase);
}

使用示例:

#include <iostream>

int main() {
    // 示例1：原始字节数组
    uint8_t bytes[] = {0x12, 0xAB, 0xFF, 0x00};
    std::string hex1 = bytesToHex(bytes, sizeof(bytes));
    std::cout << "Hex (uppercase): " << hex1 << std::endl; // 输出 "12ABFF00"

    // 示例2：使用小写字母
    std::string hex2 = bytesToHex(bytes, sizeof(bytes), false);
    std::cout << "Hex (lowercase): " << hex2 << std::endl; // 输出 "12abff00"

    // 示例3：通过 vector 传递
    std::vector<uint8_t> byte_vec = {0xDE, 0xAD, 0xBE, 0xEF};
    std::string hex3 = bytesToHex(byte_vec);
    std::cout << "Hex from vector: " << hex3 << std::endl; // 输出 "DEADBEEF"

    return 0;
}

以下是为字节流转换为十六进制字符串添加分隔符支持的C++实现：

// 支持分隔符
std::string bytesToHex(const uint8_t* data, size_t len, bool uppercase = true, char separator = '\0') {
    const char* hex_table = uppercase ?
        "0123456789ABCDEF" :
        "0123456789abcdef";
    
    std::string hex_str;
    if (len == 0) return hex_str;

    // 预计算内存：每个字节2字符 + 分隔符
    size_t total_len = len * 2;
    if (separator != '\0') {
        total_len += (len - 1); // 分隔符数量为 len-1
    }
    hex_str.reserve(total_len);

    // 逐个字节处理
    for (size_t i = 0; i < len; ++i) {
        uint8_t byte = data[i];
        hex_str.push_back(hex_table[(byte >> 4) & 0x0F]); // 高4位
        hex_str.push_back(hex_table[byte & 0x0F]);        // 低4位

        // 添加分隔符（最后一个字节不添加）
        if (separator != '\0' && i != len - 1) {
            hex_str.push_back(separator);
        }
    }

    return hex_str;
}

// 重载版本：支持 std::vector<uint8_t>
std::string bytesToHex(const std::vector<uint8_t>& data, bool uppercase = true, char separator = '\0') {
    return bytesToHex(data.data(), data.size(), uppercase, separator);
}

使用示例:

#include <iostream>

int main() {
    // 示例1：无分隔符
    std::vector<uint8_t> data1 = {0xDE, 0xAD, 0xBE, 0xEF};
    std::string hex1 = bytesToHex(data1);
    std::cout << "无分隔符: " << hex1 << std::endl; // 输出 "DEADBEEF"

    // 示例2：短横线分隔符
    std::string hex2 = bytesToHex(data1, true, '-');
    std::cout << "短横线分隔: " << hex2 << std::endl; // 输出 "DE-AD-BE-EF"

    // 示例3：冒号分隔符 + 小写字母
    std::string hex3 = bytesToHex(data1, false, ':');
    std::cout << "冒号小写分隔: " << hex3 << std::endl; // 输出 "de:ad:be:ef"

    // 示例4：单个字节
    std::vector<uint8_t> data2 = {0x12};
    std::string hex4 = bytesToHex(data2, true, '-');
    std::cout << "单字节: " << hex4 << std::endl; // 输出 "12"

    return 0;
}

十六进制字符串转字节流：

std::vector<uint8_t> hexToBytes(const std::string& hex_str) {
    // 验证输入有效性
    if (hex_str.length() % 2 != 0) {
        throw std::invalid_argument("Hex string length must be even");
    }

    // 构建反向映射表（字符 -> 4位值）
    std::vector<uint8_t> lookup(256, 0xFF); // 初始化为无效值
    for (int i = 0; i < 10; ++i) {
        lookup['0' + i] = i;              // 数字0-9
    }
    for (int i = 0; i < 6; ++i) {
        lookup['A' + i] = 10 + i;        // 大写A-F
        lookup['a' + i] = 10 + i;        // 小写a-f
    }

    std::vector<uint8_t> bytes;
    bytes.reserve(hex_str.length() / 2); // 预分配空间

    for (size_t i = 0; i < hex_str.length(); i += 2) {
        // 检查字符有效性
        uint8_t high_nibble = lookup[static_cast<uint8_t>(hex_str[i])];
        uint8_t low_nibble = lookup[static_cast<uint8_t>(hex_str[i + 1])];

        if (high_nibble == 0xFF || low_nibble == 0xFF) {
            throw std::invalid_argument("Invalid hex character");
        }

        // 组合高4位和低4位
        bytes.push_back((high_nibble << 4) | low_nibble);
    }

    return bytes;
}


std::vector<uint8_t> hexToBytesWithDelimiter(const std::string& hex_str, char delimiter = '-') {
    std::vector<uint8_t> bytes;
    std::string clean_hex;
    clean_hex.reserve(hex_str.length());

    // 移除分隔符
    for (char c : hex_str) {
        if (c != delimiter) {
            clean_hex.push_back(c);
        }
    }

    return hexToBytes(clean_hex);
}

使用示例:

#include <iostream>

int main() {
    try {
        // 示例1：标准大写字符串
        std::string hex1 = "DEADBEEF";
        auto bytes1 = hexToBytes(hex1);
        // bytes1 = {0xDE, 0xAD, 0xBE, 0xEF}

        // 示例2：混合大小写
        std::string hex2 = "1a2B3c";
        auto bytes2 = hexToBytes(hex2);
        // bytes2 = {0x1A, 0x2B, 0x3C}

        // 示例3：错误输入（长度奇数）
        std::string hex3 = "123";
        auto bytes3 = hexToBytes(hex3); // 抛出异常

    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}