错误处理

// 传统 C 风格
int open_file(const char* path, FILE** out) {
    FILE* f = fopen(path, "r");
    if (!f) {
        return -1;  // 返回错误码
    }
    *out = f;
    return 0;  // 成功返回 0
}

// 调用方
FILE* file;
int ret = open_file("data.txt", &file);
if (ret != 0) {
    printf("打开文件失败: %d\n", ret);
    return;
}
// 使用 file...

// 现代 C++ 异常
std::string read_file(const std::string& path) {
    std::ifstream file(path);
    if (!file.is_open()) {
        throw std::runtime_error("无法打开文件: " + path);
    }

    std::string content;
    std::string line;
    while (std::getline(file, line)) {
        content += line + "\n";
    }
    return content;
}

// 调用方
try {
    std::string content = read_file("data.txt");
    std::cout << content << std::endl;
} catch (const std::runtime_error& e) {
    std::cerr << "错误: " << e.what() << std::endl;
} catch (...) {
    std::cerr << "未知错误" << std::endl;
}

// std::optional - 表示可能有或没有值
#include <optional>

std::optional<int> parse_int(const std::string& str) {
    try {
        return std::stoi(str);
    } catch (...) {
        return std::nullopt;  // 解析失败
    }
}

// 调用方
auto result = parse_int("123");
if (result.has_value()) {
    int value = result.value();
    std::cout << "解析成功: " << value << std::endl;
} else {
    std::cout << "解析失败" << std::endl;
}

// 使用 value_or 提供默认值
int value = parse_int("invalid").value_or(0);

// std::expected - 类似 Rust 的 Result
#include <expected>

enum class ParseError {
    InvalidFormat,
    OutOfRange
};

std::expected<int, ParseError> parse_int(const std::string& str) {
    try {
        return std::stoi(str);
    } catch (const std::invalid_argument&) {
        return std::unexpected(ParseError::InvalidFormat);
    } catch (const std::out_of_range&) {
        return std::unexpected(ParseError::OutOfRange);
    }
}

// 调用方
auto result = parse_int("123");
if (result) {
    std::cout << "解析成功: " << *result << std::endl;
} else {
    ParseError error = result.error();
    std::cout << "解析失败: " << static_cast<int>(error) << std::endl;
}

// std::variant - 类型安全的联合体
#include <variant>

struct Success { int value; };
struct Error { std::string message; };

using Result = std::variant<Success, Error>;

Result divide(int a, int b) {
    if (b == 0) {
        return Error{"除零错误"};
    }
    return Success{a / b};
}

// 调用方
Result result = divide(10, 2);
if (std::holds_alternative<Success>(result)) {
    Success s = std::get<Success>(result);
    std::cout << "结果: " << s.value << std::endl;
} else {
    Error e = std::get<Error>(result);
    std::cout << "错误: " << e.message << std::endl;
}

// 使用 std::visit
std::visit([](auto&& arg) {
    using T = std::decay_t<decltype(arg)>;
    if constexpr (std::is_same_v<T, Success>) {
        std::cout << "成功: " << arg.value << std::endl;
    } else {
        std::cout << "错误: " << arg.message << std::endl;
    }
}, result);

// 自定义 Result 模板（类似 Rust）
template<typename T, typename E>
class Result {
public:
    static Result Ok(T value) {
        return Result(std::move(value));
    }

    static Result Err(E error) {
        return Result(std::move(error));
    }

    bool is_ok() const { return _state == State::Ok; }
    bool is_err() const { return _state == State::Err; }

    T& unwrap() {
        assert(is_ok());
        return _value;
    }

    E& unwrap_err() {
        assert(is_err());
        return _error;
    }

    // map, and_then, or_else...
private:
    enum class State { Ok, Err };
    State _state;
    union {
        T _value;
        E _error;
    };
};

// 使用示例
enum class DatabaseError {
    ConnectionFailed,
    QueryFailed
};

Result<User, DatabaseError> get_user(int uid) {
    if (uid <= 0) {
        return Result<User, DatabaseError>::Err(DatabaseError::QueryFailed);
    }
    return Result<User, DatabaseError>::Ok(User{uid, "Alice"});
}

auto result = get_user(123);
if (result.is_ok()) {
    User user = result.unwrap();
    std::cout << "用户: " << user.name << std::endl;
} else {
    DatabaseError err = result.unwrap_err();
    std::cout << "错误: " << static_cast<int>(err) << std::endl;
}