C++异常处理与constexpr冲突吗 编译期异常处理限制

constexpr int divide(int a, int b) {
    // 假设这里能用try-catch
    // try {
    //     if (b == 0) {
    //         throw std::runtime_error("Division by zero!"); // 编译期会报错
    //     }
    //     return a / b;
    // } catch (const std::runtime_error& e) {
    //     // 编译期无法处理
    //     return 0; // 或者其他错误码
    // }
    if (b == 0) {
        // 在constexpr语境下，如果b为0，这里会是编译错误
        // 因为除以0是非法的，即使没有显式throw
        // 或者，如果你想传递错误状态：
        // return some_error_value;
    }
    return a / b;
}

// 尝试在constexpr语境中使用
// constexpr int result = divide(10, 0); // 编译错误：常量表达式中除以0

template<typename T>
constexpr T check_positive(T value) {
    static_assert(std::is_arithmetic_v<T>, "T must be an arithmetic type!");
    static_assert(value > 0, "Value must be positive in constexpr context!"); // 编译期检查
    return value;
}

// constexpr int x = check_positive(-5); // 编译错误：Value must be positive...
constexpr int y = check_positive(10); // OK

#include <optional>
#include <string_view>

constexpr std::optional<int> find_char_pos(std::string_view s, char c) {
    for (std::size_t i = 0; i < s.length(); ++i) {
        if (s[i] == c) {
            return i;
        }
    }
    return std::nullopt; // 表示未找到
}

constexpr auto pos1 = find_char_pos("hello", 'l'); // std::optional<int> 值为 2
constexpr auto pos2 = find_char_pos("world", 'z'); // std::optional<int> 为 std::nullopt

// 编译期使用
static_assert(pos1.has_value() && *pos1 == 2);
static_assert(!pos2.has_value());

#include <variant>
#include <string_view>

enum class ParseError {
    EmptyString,
    InvalidCharacter,
    Overflow
};

constexpr std::variant<int, ParseError> parse_int(std::string_view s) {
    if (s.empty()) {
        return ParseError::EmptyString;
    }
    int result = 0;
    for (char c : s) {
        if (c < '0' || c > '9') {
            return ParseError::InvalidCharacter;
        }
        // 简单模拟，不处理溢出
        result = result * 10 + (c - '0');
    }
    return result;
}

constexpr auto val1 = parse_int("123"); // std::variant<int, ParseError> 值为 123
constexpr auto val2 = parse_int("");    // std::variant<int, ParseError> 值为 ParseError::EmptyString
constexpr auto val3 = parse_int("abc"); // std::variant<int, ParseError> 值为 ParseError::InvalidCharacter

// 编译期检查
static_assert(std::holds_alternative<int>(val1) && std::get<int>(val1) == 123);
static_assert(std::holds_alternative<ParseError>(val2) && std::get<ParseError>(val2) == ParseError::EmptyString);

#include <iostream>
#include <stdexcept>

constexpr int get_value(int divisor) {
    // 编译期：如果divisor为0，这里会导致编译错误
    // 运行时：如果divisor为0，这里会抛出std::runtime_error
    if (divisor == 0) {
        throw std::runtime_error("Cannot divide by zero!"); // 在constexpr语境下会报错
    }
    return 100 / divisor;
}

int main() {
    // 编译期上下文：
    // constexpr int val1 = get_value(2); // OK, val1 = 50
    // constexpr int val2 = get_value(0); // 编译错误：常量表达式中除以0，因为get_value的throw在constexpr语境下是不允许的

    // 运行时上下文：
    try {
        int runtime_val1 = get_value(20);
        std::cout << "Runtime val1: " << runtime_val1 << std::endl; // Output: 5

        int runtime_val2 = get_value(0); // 这里会抛出异常
        std::cout << "Runtime val2: " << runtime_val2 << std::endl;
    } catch (const std::runtime_error& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl; // Output: Caught exception: Cannot divide by zero!
    }

    return 0;
}