如何在C++中将十六进制字符串转换为整数_C++十六进制字符串转换技巧

#include <iostream>
#include <string>
#include <stdexcept> // 用于异常处理

int main() {
    std::string hexString = "A3F"; // 这是一个十六进制字符串
    int decimalValue;

    try {
        decimalValue = std::stoi(hexString, nullptr, 16);
        std::cout << "十六进制字符串 \"" << hexString << "\" 转换为整数是: " << decimalValue << std::endl;

        hexString = "deadbeef"; // 另一个例子
        decimalValue = std::stoi(hexString, nullptr, 16);
        std::cout << "十六进制字符串 \"" << hexString << "\" 转换为整数是: " << decimalValue << std::endl;

        hexString = "0x1A"; // 带有0x前缀的，std::stoi也能处理
        decimalValue = std::stoi(hexString, nullptr, 16);
        std::cout << "十六进制字符串 \"" << hexString << "\" 转换为整数是: " << decimalValue << std::endl;

    } catch (const std::invalid_argument& e) {
        std::cerr << "转换错误：输入字符串不是有效的十六进制数。详情: " << e.what() << std::endl;
    } catch (const std::out_of_range& e) {
        std::cerr << "转换错误：结果超出整数类型范围。详情: " << e.what() << std::endl;
    }

    return 0;
}

// ... (上面已经有try-catch的示例了，这里就不重复贴完整代码了)
try {
    // 尝试转换
    int value = std::stoi(hexStr, nullptr, 16);
    // 转换成功后的逻辑
} catch (const std::invalid_argument& e) {
    // 处理无效参数错误，比如记录日志、给用户提示
    std::cerr << "错误：输入字符串 \"" << hexStr << "\" 不是有效的十六进制数。详情: " << e.what() << std::endl;
    // 可以返回一个错误码或者默认值
} catch (const std::out_of_range& e) {
    // 处理超出范围错误
    std::cerr << "错误：十六进制数 \"" << hexStr << "\" 太大，超出int类型范围。详情: " << e.what() << std::endl;
    // 同样可以返回错误码或默认值
}

#include <iostream>
#include <string>
#include <cctype> // 用于std::isxdigit

int hexCharToDecimal(char c) {
    if (c >= '0' && c <= '9') {
        return c - '0';
    } else if (c >= 'a' && c <= 'f') {
        return c - 'a' + 10;
    } else if (c >= 'A' && c <= 'F') {
        return c - 'A' + 10;
    }
    // 如果不是有效的十六进制字符，可以抛出异常或返回错误码
    throw std::invalid_argument("Invalid hex character");
}

int customHexToInt(const std::string& hexStr) {
    int result = 0;
    int power = 0;

    // 可以选择跳过0x前缀
    size_t start_index = 0;
    if (hexStr.length() >= 2 && hexStr[0] == '0' && (hexStr[1] == 'x' || hexStr[1] == 'X')) {
        start_index = 2;
    }

    // 从字符串末尾开始处理，这样更容易计算16的幂
    for (int i = hexStr.length() - 1; i >= (int)start_index; --i) {
        char c = hexStr[i];
        if (!std::isxdigit(c)) { // 检查是否是十六进制数字
            throw std::invalid_argument("String contains non-hexadecimal characters.");
        }
        int decimalValue = hexCharToDecimal(c);

        // 避免溢出检查，这里简化处理，实际生产代码需要更严格的检查
        // result += decimalValue * pow(16, power); // 不推荐使用pow，浮点数精度问题

        // 更高效且避免浮点数问题的方法：
        // 每次循环将当前结果乘以16，然后加上新解析的数字
        // 但是这里我们是从右到左，所以是累加乘方
        // 另一种更常见且更简单的实现是从左到右： result = result * 16 + digit_value;
        // 让我们改用从左到右的实现，更直观
    }

    // 从左到右的实现
    result = 0;
    for (size_t i = start_index; i < hexStr.length(); ++i) {
        char c = hexStr[i];
        if (!std::isxdigit(c)) {
            throw std::invalid_argument("String contains non-hexadecimal characters.");
        }
        int digitValue = hexCharToDecimal(c);

        // 每次迭代，将当前结果左移4位（相当于乘以16），然后加上新解析的数字
        // 或者直接 result = result * 16 + digitValue;

        // 溢出检查 (简化版，实际需要考虑int的最大值)
        if (result > (INT_MAX / 16) || (result == (INT_MAX / 16) && digitValue > (INT_MAX % 16))) {
            throw std::out_of_range("Hex string causes integer overflow.");
        }
        result = result * 16 + digitValue;
    }

    return result;
}

int main() {
    std::string hex1 = "1A";
    std::string hex2 = "0xFF";
    std::string hex3 = "abc";
    std::string hex4 = "123G"; // 无效字符
    std::string hex5 = "FFFFFFFF"; // 可能溢出int

    try {
        std::cout << "\"" << hex1 << "\" -> " << customHexToInt(hex1) << std::endl;
        std::cout << "\"" << hex2 << "\" -> " << customHexToInt(hex2) << std::endl;
        std::cout << "\"" << hex3 << "\" -> " << customHexToInt(hex3) << std::endl;
        // std::cout << "\"" << hex4 << "\" -> " << customHexToInt(hex4) << std::endl; // 会抛出异常
        // std::cout << "\"" << hex5 << "\" -> " << customHexToInt(hex5) << std::endl; // 可能抛出溢出异常
    } catch (const std::exception& e) {
        std::cerr << "自定义转换错误: " << e.what() << std::endl;
    }

    return 0;
}