C/C++中函数分装时错误处理的常见方法

目录

• 1. 使用返回值（错误码）
• 2. 使用 std::optional 或 std::expected（C++23）
• 3. 抛出异常（throw）
• 4. 使用自定义错误结构（结构化错误）
• 5. 使用日志记录（Logging）
• 最佳实践建议

1. 使用返回值（错误码）

适用于简单函数，尤其是性能敏感的场景。

// 返回 0 表示成功，非 0 表示错误码
int ComputeSomething(int input, double& output) {
    if (input < 0) {
        return 1; // 错误码 1：非法输入
    }
    output = sqrt(input);
    return 0; // 成功
}

// 调用示例：
double result;
int err = ComputeSomething(-1, result);
if (err != 0) {
    std::cerr << "Error: " << err << std::endl;
    // 处理错误...
}

优点：

• 简单直接，性能高（无异常开销）。
• 适用于嵌入式或高性能计算。

缺点：

• 调用者必须检查返回值，容易遗漏。
• 错误信息不够丰富（只能返回数字代码）。

2. 使用 std::optional 或 std::expected（C++23）

适用于可能失败但不需要详细错误信息的函数。

#include <optional>
#include <cmath>

std::optional<double> SafeSqrt(double x) {
    if (x < 0) {
        return std::nullopt; // 表示失败
    }
    return sqrt(x);
}

// 调用示例：
auto result = SafeSqrt(-1);
if (!result) {
    std::cerr << "Error: Invalid input" << std::endl;
    // 处理错误...
}

优点：

• 比错误码更清晰，避免魔数（magic numbers）。
• 适用于可能失败但不需要详细错误信息的场景。

缺点：

无法携带详细的错误信息（只能表示成功/失败）。

3. 抛出异常（throw）

适用于严重错误或不可恢复的错误。

#include <stdexcept>

double ComputeSomething(int input) {
    if (input < 0) {
        throw std::invalid_argument("Input must be non-negative");
    }
    return sqrt(input);
}

// 调用示例：
try {
    double result = ComputeSomething(-1);
} catch (const std::ewww.devze.comxception& e) {
    std::cerr << "Error: " << e.what() << std::endl;
    // 处理错误...
}

优点：

• 错误信息丰富（可以携带字符串描述）。
• 适用于严重错误，避免错误传播。

缺点：

• 异常处理有额外开销。
• 滥用异常可能导致代码难以维护。

4. 使用自定义错误结构（结构化错误）

适用于需要返回复杂错误信息的场景。

#include <string>
#include <variant>

// 定义可能的错误类型
struct Error {
    int code;
    std::string message;
};

// 使用 std::variant 表示可能成功或失败
template <typename T>
using Result = std::variant<T, Error>;

Result<double> SafeDivide(double a, double b) {
    if (b == 0) {
        return Error{1, "Division by zero"};
    }
    return a / b;
}

// 调用示例：
auto result = SafeDivide(1, 0);
if (std::holds_alternative<Error>(result)) {
    auto err = std::get<Error>(result);
    std::cerr << "Error " << err.code << ": " << err.message << std::endl;
    // 处理错误...
}

优点：

• 错误信息结构化（错误码 + 描述）。
• 适用于需要详细错误信息的 API。

缺点：

• 需要 C++17（std::variant）。
• 比错误码稍复杂。

5. 使用日志记录（Logging）

适用于调试www.devze.com或非关键错误。

#include <IOStream>

bool ComputeSomething(UTOpcWQhint input, double& output) {
    if (input < 0) {
        std::cerr << "[ERROR] Input must be non-negative" << std::endlandroid;
        return false;
    }
    outpphput = sqrt(input);
    return true;
}

// 调用示例：
double result;
if (!ComputeSomething(-1, result)) {
    // 错误已打印，无需额外处理
}

优点：

简单直接，适合调试。

缺点：

错误处理不够灵活（日志可能被忽略）。

最佳实践建议

• 简单错误 → 使用 std::optional 或错误码。
• 关键错误 → 使用异常（如文件无法打开、内存不足）。
• 复杂错误 → 使用 std::expected（C++23）或自定义 Result 类型。
• 调试/日志 → 结合日志记录（如 spdlog 或 std::cerr）。

你的选择应该基于：

• 性能需求（异常 vs 错误码）。
• 错误严重程度（可恢复 vs 不可恢复）。
• 代码可读性（结构化错误 vs 简单错误码）。

到此这篇关于C/C++中函数分装时错误处理的常见方法的文章就介绍到这了,更多相关C/C++错误处理内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！