C++23 `std::expected`的零开销实现：比传统异常和`std::optional`更安全的错误处理

C++23 std::expected：零开销错误处理的未来

大家好！今天我们来深入探讨C++23中引入的std::expected，一个旨在提供比传统异常和std::optional更安全、更高效错误处理机制的关键特性。我们将分析其设计理念、使用方法、性能考量，并与其他错误处理方法进行对比，最终探讨其在实际项目中的应用。

1. 错误处理的挑战与现有方案

在C++中，错误处理一直是开发者面临的一项挑战。传统的错误处理机制包括：

• 返回值: 函数通过返回值指示成功或失败。例如，返回一个错误码或者一个特殊的值（例如nullptr）。

  • 优点: 简单直接，易于理解。
  • 缺点: 容易被忽略，需要手动检查返回值，且返回值本身可能需要承载有用的数据。

• 异常: 使用try-catch块捕获和处理异常。

  • 优点: 可以将错误处理逻辑集中到一起，避免代码分散。
  • 缺点: 异常处理的开销较高，可能导致性能下降，尤其是在频繁抛出异常的情况下。此外，异常的不可预测性可能使代码更难调试和维护。

• std::optional: 表示一个值可能存在，也可能不存在。可以用来指示函数是否成功返回了一个值。

  • 优点: 比简单的返回值方式更安全，避免了空指针等问题。
  • 缺点: 只能表示成功或失败，无法携带错误信息。如果需要知道失败原因，需要额外的信息传递机制。

下面是一个表格，总结了这三种方法的优缺点：

方法	优点	缺点
返回值	简单直接，易于理解。	容易被忽略，需要手动检查返回值，且返回值本身可能需要承载有用的数据。
异常	可以将错误处理逻辑集中到一起，避免代码分散。	开销较高，可能导致性能下降，尤其是在频繁抛出异常的情况下。此外，异常的不可预测性可能使代码更难调试和维护。
std::optional	比简单的返回值方式更安全，避免了空指针等问题。	只能表示成功或失败，无法携带错误信息。如果需要知道失败原因，需要额外的信息传递机制。

这些现有的方法各有优缺点，但在某些情况下，都无法满足对安全性、性能和错误信息传递的需求。std::expected旨在填补这些空白。

2. std::expected：设计理念与基本用法

std::expected<T, E> 是一种表示可能包含类型为 T 的值（成功情况）或类型为 E 的错误（失败情况）的类型。 它的设计目标是：

• 安全性: 强制用户处理错误情况，避免忽略错误。
• 效率: 避免异常处理的开销，提供接近无开销的错误处理。
• 信息丰富: 可以携带错误信息，方便调试和错误诊断。

基本用法示例：

#include <expected>
#include <iostream>
#include <string>

enum class ErrorCode {
    InvalidInput,
    DivideByZero
};

std::expected<double, ErrorCode> divide(double numerator, double denominator) {
    if (denominator == 0.0) {
        return std::unexpected(ErrorCode::DivideByZero);
    }
    if (numerator < 0) {
        return std::unexpected(ErrorCode::InvalidInput);
    }
    return numerator / denominator;
}

int main() {
    auto result = divide(10.0, 2.0);

    if (result) {
        std::cout << "Result: " << *result << std::endl;
    } else {
        switch (result.error()) {
            case ErrorCode::DivideByZero:
                std::cerr << "Error: Divide by zero!" << std::endl;
                break;
            case ErrorCode::InvalidInput:
                std::cerr << "Error: Invalid input!" << std::endl;
                break;
        }
    }

    auto result2 = divide(5.0, 0.0);
    if (result2) {
        std::cout << "Result: " << *result2 << std::endl;
    } else {
        // 使用 `std::move(result2).error()` 避免拷贝
        switch (std::move(result2).error()) {
            case ErrorCode::DivideByZero:
                std::cerr << "Error: Divide by zero!" << std::endl;
                break;
            case ErrorCode::InvalidInput:
                std::cerr << "Error: Invalid input!" << std::endl;
                break;
        }
    }

    auto result3 = divide(-5.0, 2.0);
     if (result3) {
        std::cout << "Result: " << *result3 << std::endl;
    } else {
        // 使用 `std::move(result3).error()` 避免拷贝
        switch (std::move(result3).error()) {
            case ErrorCode::DivideByZero:
                std::cerr << "Error: Divide by zero!" << std::endl;
                break;
            case ErrorCode::InvalidInput:
                std::cerr << "Error: Invalid input!" << std::endl;
                break;
        }
    }

    return 0;
}

在这个例子中：

• divide 函数返回一个 std::expected<double, ErrorCode>，表示可能返回一个 double 值（成功）或一个 ErrorCode（失败）。
• 如果除数为零，则返回一个包含 ErrorCode::DivideByZero 的 std::unexpected 对象。
• 如果分子为负数，则返回一个包含 ErrorCode::InvalidInput 的 std::unexpected 对象。
• 在 main 函数中，我们使用 if (result) 检查是否成功，并使用 *result 访问成功的值。
• 如果失败，则使用 result.error() 访问错误码，并根据错误码进行处理。
• 使用std::move(result).error()，避免了error的拷贝构造，提升了性能。

关键组成部分：

• std::expected<T, E>: 模板类，表示预期返回类型为 T，错误类型为 E。
• std::unexpected<E>: 表示一个错误，包含类型为 E 的错误值。std::expected 在失败时会包含一个 std::unexpected 对象。
• .has_value(): 返回 true 如果 std::expected 包含一个值，否则返回 false (即包含一个错误)。
• *: 解引用运算符，用于访问 std::expected 中包含的值 (仅当 has_value() 返回 true 时才能使用)。
• .value(): 返回 std::expected 中包含的值。如果 std::expected 包含一个错误，则抛出一个异常 (通常是 std::bad_expected_access)。 尽量避免使用，优先使用has_value()和*。
• .error(): 返回 std::expected 中包含的错误。如果 std::expected 包含一个值，则行为未定义。请注意，为了避免拷贝，特别是当错误类型E比较大的时候，应该优先使用std::move(result).error()。
• .value_or(T v): 如果std::expected包含一个值，则返回该值，否则返回v。
• .transform(F f): 如果std::expected包含一个值，则使用函数f对该值进行转换，并返回一个新的std::expected，包含转换后的值。如果std::expected包含一个错误，则直接返回，不进行任何转换。
• .transform_error(F f): 如果std::expected包含一个错误，则使用函数f对该错误进行转换，并返回一个新的std::expected，包含转换后的错误。如果std::expected包含一个值，则直接返回，不进行任何转换。
• .and_then(F f): 如果std::expected包含一个值，则使用该值作为参数调用函数f，函数f返回一个新的std::expected，并将其作为结果返回。如果std::expected包含一个错误，则直接返回，不调用函数f。
• .or_else(F f): 如果std::expected包含一个错误，则调用函数f，函数f返回一个新的std::expected，并将其作为结果返回。如果std::expected包含一个值，则直接返回，不调用函数f。

3. std::expected vs. std::optional

std::expected 和 std::optional 都用于处理可能缺失的值，但它们之间存在关键区别：

• std::optional: 只能表示值存在或不存在，没有提供关于缺失原因的信息。
• std::expected: 提供了关于缺失原因的信息，可以携带一个错误值。

因此，std::optional 适用于简单的 "有/无" 情况，而 std::expected 适用于需要知道为什么值缺失的情况。

示例：

#include <optional>
#include <expected>
#include <iostream>

std::optional<int> parseIntOptional(const std::string& str) {
    try {
        return std::stoi(str);
    } catch (const std::exception&) {
        return std::nullopt;
    }
}

enum class ParseError {
    InvalidFormat,
    Overflow
};

std::expected<int, ParseError> parseIntExpected(const std::string& str) {
    try {
        size_t pos = 0;
        int value = std::stoi(str, &pos);
        if (pos != str.length()) {
            return std::unexpected(ParseError::InvalidFormat);
        }
        return value;
    } catch (const std::out_of_range&) {
        return std::unexpected(ParseError::Overflow);
    } catch (const std::invalid_argument&) {
         return std::unexpected(ParseError::InvalidFormat);
    }
}

int main() {
    auto optionalResult = parseIntOptional("123");
    if (optionalResult) {
        std::cout << "Optional: " << *optionalResult << std::endl;
    } else {
        std::cout << "Optional: Invalid input" << std::endl; // 只能知道输入无效，无法知道原因
    }

    auto expectedResult = parseIntExpected("abc");
    if (expectedResult) {
        std::cout << "Expected: " << *expectedResult << std::endl;
    } else {
        switch (expectedResult.error()) {
            case ParseError::InvalidFormat:
                std::cout << "Expected: Invalid format" << std::endl;
                break;
            case ParseError::Overflow:
                std::cout << "Expected: Overflow" << std::endl;
                break;
        }
    }

    return 0;
}

在这个例子中，parseIntOptional 只能告诉我们字符串是否可以转换为整数，而 parseIntExpected 可以告诉我们转换失败的原因（InvalidFormat 或 Overflow）。

4. std::expected vs. 异常

std::expected 提供了一种替代异常的错误处理机制，尤其是在以下情况下：

• 性能敏感的代码: 异常处理的开销较高，而 std::expected 的开销通常较低，尤其是在不发生错误的情况下。
• 需要显式错误处理的代码: std::expected 强制用户处理错误情况，避免忽略错误。
• 不适合使用异常的代码: 例如，某些嵌入式系统或实时系统可能禁止使用异常。

示例：

#include <expected>
#include <iostream>
#include <stdexcept>

// 使用异常处理
int divideWithException(int numerator, int denominator) {
    if (denominator == 0) {
        throw std::runtime_error("Divide by zero!");
    }
    return numerator / denominator;
}

// 使用 std::expected
std::expected<int, std::string> divideWithExpected(int numerator, int denominator) {
    if (denominator == 0) {
        return std::unexpected("Divide by zero!");
    }
    return numerator / denominator;
}

int main() {
    // 使用异常处理
    try {
        int result = divideWithException(10, 0);
        std::cout << "Result: " << result << std::endl;
    } catch (const std::runtime_error& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    // 使用 std::expected
    auto result = divideWithExpected(10, 0);
    if (result) {
        std::cout << "Result: " << *result << std::endl;
    } else {
        std::cerr << "Error: " << result.error() << std::endl;
    }

    return 0;
}

在这个例子中，divideWithException 使用异常处理，而 divideWithExpected 使用 std::expected。 使用 std::expected 避免了异常处理的开销，并强制用户显式处理错误情况。

性能考量：

在没有错误发生的情况下，std::expected 的开销通常比异常处理更低。 这是因为异常处理需要在运行时维护调用栈信息，以便在抛出异常时进行栈展开。 而 std::expected 只需要在函数返回时复制或移动值或错误。

然而，在错误频繁发生的情况下，std::expected 的开销可能会高于异常处理。 这是因为每次返回 std::expected 时，都需要进行一次类型检查和值/错误的复制或移动。 而异常处理只需要在抛出异常时进行栈展开。

因此，在选择错误处理机制时，需要根据具体的应用场景和性能需求进行权衡。 如果性能至关重要，并且错误不经常发生，那么 std::expected 可能是一个更好的选择。 如果错误频繁发生，并且可以接受一定的性能开销，那么异常处理可能更合适。

5. 高级用法：transform, transform_error, and_then, or_else

std::expected 提供了一组函数，用于方便地处理成功和失败的情况，并将多个 std::expected 对象组合在一起。

• transform(F f): 如果 std::expected 包含一个值，则使用函数 f 对该值进行转换，并返回一个新的 std::expected，包含转换后的值。如果 std::expected 包含一个错误，则直接返回，不进行任何转换。
• transform_error(F f): 如果 std::expected 包含一个错误，则使用函数 f 对该错误进行转换，并返回一个新的 std::expected，包含转换后的错误。如果 std::expected 包含一个值，则直接返回，不进行任何转换。
• and_then(F f): 如果 std::expected 包含一个值，则使用该值作为参数调用函数 f，函数 f 返回一个新的 std::expected，并将其作为结果返回。如果 std::expected 包含一个错误，则直接返回，不调用函数 f。 可以理解为flatMap操作。
• or_else(F f): 如果 std::expected 包含一个错误，则调用函数 f，函数 f 返回一个新的 std::expected，并将其作为结果返回。如果 std::expected 包含一个值，则直接返回，不调用函数 f。

示例：

#include <expected>
#include <iostream>
#include <string>

enum class ErrorCode {
    InvalidInput,
    DivideByZero
};

std::expected<double, ErrorCode> divide(double numerator, double denominator) {
    if (denominator == 0.0) {
        return std::unexpected(ErrorCode::DivideByZero);
    }
    if (numerator < 0) {
        return std::unexpected(ErrorCode::InvalidInput);
    }
    return numerator / denominator;
}

std::expected<int, std::string> stringToInt(const std::string& str) {
    try {
        return std::stoi(str);
    } catch (const std::exception& e) {
        return std::unexpected(e.what());
    }
}

int main() {
    // transform
    auto result1 = divide(10.0, 2.0)
        .transform([](double value) { return static_cast<int>(value); });

    if (result1) {
        std::cout << "Transformed result: " << *result1 << std::endl;
    } else {
        std::cerr << "Error: " << static_cast<int>(result1.error()) << std::endl;
    }

    // transform_error
    auto result2 = divide(10.0, 0.0)
        .transform_error([](ErrorCode error) {
            return std::string("Error code: ") + std::to_string(static_cast<int>(error));
        });

    if (result2) {
        std::cout << "Result: " << *result2 << std::endl;
    } else {
        std::cerr << "Error: " << result2.error() << std::endl;
    }

    // and_then
    auto result3 = stringToInt("123")
        .and_then([](int value) { return divide(static_cast<double>(value), 2.0); });

    if (result3) {
        std::cout << "Result: " << *result3 << std::endl;
    } else {
        std::cerr << "Error: " << result3.error() << std::endl;
    }

    // or_else
    auto result4 = divide(10.0, 0.0)
        .or_else([]() -> std::expected<double, ErrorCode> { return divide(10.0, 2.0); });

    if (result4) {
        std::cout << "Result: " << *result4 << std::endl;
    } else {
        std::cerr << "Error: " << static_cast<int>(result4.error()) << std::endl;
    }

    return 0;
}

这些函数可以帮助我们编写更简洁、更易于理解的错误处理代码。 它们允许我们将多个操作链接在一起，并在出现错误时进行集中处理。

6. 实际应用场景

std::expected 适用于各种实际应用场景，例如：

• 文件 I/O: 读取或写入文件时，可能会发生各种错误，例如文件不存在、权限不足等。std::expected 可以用来表示文件操作的结果，并携带错误信息。
• 网络编程: 网络连接可能会中断、数据可能会丢失等。std::expected 可以用来表示网络操作的结果，并携带错误信息。
• 数据库访问: 数据库查询可能会失败、数据可能会无效等。std::expected 可以用来表示数据库操作的结果，并携带错误信息。
• 解析器: 解析器在解析输入时，可能会遇到语法错误、格式错误等。std::expected 可以用来表示解析结果，并携带错误信息。
• 数学计算: 数学计算可能会遇到除零错误、溢出错误等。std::expected 可以用来表示计算结果，并携带错误信息。

在这些场景中，使用 std::expected 可以提高代码的安全性、可靠性和可维护性。

7. 注意事项

• 错误类型的选择: 选择合适的错误类型非常重要。 错误类型应该能够准确地描述错误的原因，并提供足够的信息用于调试和错误诊断。
• 错误处理策略: 需要制定明确的错误处理策略。 应该决定如何处理不同的错误情况，以及如何向用户报告错误。
• 性能考量: 在性能敏感的代码中，需要仔细评估 std::expected 的开销。 如果错误频繁发生，并且性能至关重要，那么可能需要考虑其他错误处理机制。
• 不要滥用 value(): value() 函数会在 std::expected 包含错误时抛出异常。 应该尽量避免使用 value() 函数，而应该使用 has_value() 和 * 运算符来安全地访问值。
• 避免不必要的拷贝: 尤其是error类型比较大的时候，在访问error的时候，应该优先使用std::move(result).error()。

8. std::expected 带来的好处

std::expected 提供了一种更安全、更高效、更灵活的错误处理机制。 它可以帮助我们编写更健壮、更可靠、更易于维护的代码。 通过使用 std::expected，我们可以：

• 避免忽略错误: std::expected 强制用户处理错误情况，避免忽略错误。
• 提供更丰富的错误信息: std::expected 可以携带错误信息，方便调试和错误诊断。
• 提高代码的性能: std::expected 的开销通常比异常处理更低，尤其是在不发生错误的情况下。
• 简化代码的逻辑: std::expected 提供了一组函数，用于方便地处理成功和失败的情况，并将多个 std::expected 对象组合在一起。

9. 总结

总而言之，std::expected是C++23引入的强大的错误处理工具，它在安全性、效率和信息量方面优于传统的异常和std::optional，为开发者提供了更多选择。

希望今天的讲解能够帮助大家更好地理解和使用 std::expected。 谢谢大家！

更多IT精英技术系列讲座，到智猿学院