std::variant vs std::expected：C++20对比分析与选择指南

# 1. C++20新特性的引入与概览

C++20标准作为C++语言发展历史上的重要里程碑，引入了一系列革新的特性，旨在使C++成为更现代、更高效、更易于使用的编程语言。在本章中，我们将简要介绍C++20的新特性，并对其做初步的概览。

首先，C++20扩展了语言的类型系统，新增了诸如`std::span`和`std::mdspan`等非拥有的视图，使得对数据的访问更为灵活。这些视图可以看作是对现有数据结构的一种轻量级引用，无需额外的数据复制。

紧接着，我们将会重点讨论模块化编程的引入，它解决了头文件与源文件分离的编程范式中常见的问题，例如头文件膨胀和编译时间的增加。C++20的模块提供了更细粒度的控制，让编译器在处理跨文件依赖时更为高效。

此外，C++20还增强了并发和并行编程的支持，引入了诸如协程（Coroutines）、原子智能指针和诸如`std::jthread`这样的新线程类。这些特性旨在简化多线程应用的开发，提供更加优雅的方式来编写同步和异步代码。

最后，我们将探讨C++20对现有库的扩展，包括新算法、新容器以及`std::expected`和`std::variant`等新类型的加入，为错误处理和类型安全提供了更多选择。

通过本章的内容，读者可以对C++20所带来变化的全貌有一个快速而准确的认识。接下来的章节，我们将深入到具体的特性中，探索其细节和实际应用。

# 2. 理解std::variant的基本原理

## 2.1 std::variant的定义与初始化

### 2.1.1 variant的结构和设计理念

`std::variant` 是 C++17 标准库中引入的一种类型安全的联合体，它允许在一个类型中存储一个值，但这个值可以是预定义的一组类型中的任意一个。与传统的联合体（union）不同，`std::variant` 提供了类型安全的保证，因此，你可以访问存储值的类型时不会有任何歧义。

它的设计理念是提供一个类型安全、灵活的数据结构，来替代C++98中未类型安全的联合体（union）以及Boost.Variant库。`std::variant` 允许开发者定义一组可能的类型，当一个`variant`对象被构造时，它会存储一个当前值，并且可以动态地改变这个值的类型。

举个例子，假设我们需要一个可以存储整数或者浮点数的变量，而不希望使用`boost::variant`或者原始联合体。我们可以使用`std::variant<int, double>`来创建这样一个变量。这不仅提供了类型安全，而且还可以通过访问索引来获取当前存储值的类型信息。

### 2.1.2 variant的类型初始化与赋值

初始化一个 `std::variant` 对象可以通过直接传递值来实现。编译器会根据提供的值的类型，来决定使用哪个类型构造函数。例如：

std::variant<int, double> myVariant = 42; // int 类型

或者

std::variant<int, double> myVariant = 3.14; // double 类型

如果需要显式指定存储的类型，则可以使用构造函数：

std::variant<int, double> myVariant2{std::in_place_type_t<double>{}};

赋值操作也很直观。可以直接赋值，如果赋值的类型与当前存储的类型不匹配，variant将执行类型转换（如果可能的话）：

myVariant = 100; // 直接赋值，myVariant 仍然是 int 类型
myVariant = 3.14; // 类型不匹配，执行隐式转换，myVariant 变为 double 类型

在赋值时，如果无法将赋值的类型转换为存储的类型，将会抛出一个 `std::bad_variant_access` 异常。因此，在访问variant存储的值之前，务必确认其当前类型，这通常通过 `std::holds_alternative` 函数来完成。

if (std::holds_alternative<int>(myVariant)) {
    int i = std::get<int>(myVariant);
    // 使用 i
}

以上初始化和赋值方法展示了std::variant的灵活性和实用性，使其成为处理多种类型数据的理想选择。

## 2.2 std::variant的操作与访问

### 2.2.1 访问variant中的值

访问 `std::variant` 中存储的值可以通过 `std::get` 函数，但是在此之前，需要确认当前存储值的类型。为了安全访问，应使用 `std::holds_alternative` 检查当前的存储类型：

if (std::holds_alternative<int>(myVariant)) {
    int i = std::get<int>(myVariant); // 确保类型安全，不会抛出异常
}

如果尝试从一个 `std::variant` 中获取一个与当前存储类型不匹配的值，将抛出 `std::bad_variant_access` 异常。因此，始终在获取值前检查类型是一个好的实践。

另一种方法是使用 `std::get_if`，这是一个函数模板，允许通过指针安全地访问存储的值，这在多线程环境中非常有用，因为它可以避免异常抛出，而不会产生异常安全问题：

int* intPtr = std::get_if<int>(&myVariant);
if (intPtr) {
    std::cout << *intPtr << std::endl;
} else {
    // 不是 int 类型
}

### 2.2.2 variant的异常安全性

`std::variant` 的异常安全性主要涉及赋值和访问操作。如果赋值操作失败（例如，尝试存储一个不兼容类型的值），会抛出异常。而访问操作，如 `std::get`，若类型不匹配，也会抛出异常。因此，为了编写异常安全的代码，开发者需要确保对当前存储的类型进行适当的检查，以避免捕获异常。

异常安全的代码示例：

try {
    if (std::holds_alternative<int>(myVariant)) {
        int i = std::get<int>(myVariant);
    } else {
        throw std::runtime_error("存储的类型不匹配");
    }
} catch(const std::exception& e) {
    std::cerr << "发生异常: " << e.what() << '\n';
}

## 2.3 std::variant的限制与注意事项

### 2.3.1 variant的性能开销

使用 `std::variant` 会有一定的性能开销。相对于普通类型，`std::variant` 需要额外的空间存储类型信息，并且在运行时进行类型检查和转换操作。这意味着对于性能敏感的应用，如游戏开发或者嵌入式系统，`std::variant` 可能不是最优选择。

由于 `std::variant` 需要维护多个可能的类型，并且存储当前激活的类型信息，因此，它引入了额外的内存开销和间接的访问成本。每个 `std::variant` 实例至少需要与最大可能类型相同的大小，再加上额外的存储空间来维护当前激活的类型。

性能开销的考虑因素示例表格：

| 类型 | 占用字节数 | 备注 |
| ------------ | ---------- | ------------------------------- |
| int | 4 | 基本整型 |
| double | 8 | 双精度浮点类型 |
| std::variant<int, double> | 16 | 包含 int 和 double 的 variant |

*说明：实际占用字节可能因编译器实现和平台不同而有所变化。*

### 2.3.2 variant的局限性和最佳实践

尽管 `std::variant` 提供了强大而灵活的功能，但它也有一些局限性。首先，它不能存储引用类型，因为引用需要绑定到一个特定对象上。此外，它也不支持虚函数和RTTI（运行时类型信息），因此，不能通过 `std::variant` 的类型来进行多态操作。

对于引用类型的限制，可以通过使用指针类型或者std::reference_wrapper来绕过。例如，如果我们希望存储一个引用，可以使用std::reference_wrapper包装原始引用：

int value = 42;
std::variant<std::reference_wrapper<int>> refVariant = std::ref(value);

最佳实践包括合理地管理 `std::variant` 的大小和生命周期，注意避免不必要的性能开销，以及在使用之前总是检查存储的类型。此外，编写异常安全的代码也是使用 `std::variant` 时应考虑的重要方面。

在实际应用中，最佳实践还涉及到对 `std::variant` 的类型成员进行访问和处理时，始终使用类型安全的访问方法，例如 `std::get_if`。这种方法不仅提供类型安全，还能提高代码的效率和稳定性。

# 3. std::expected的设计与优势

## 3.1 std::expected的起源与定义
### 3.1.1 expected的引入背景

在传统的C++程序设计中，错误处理往往是通过异常机制来实现的。然而，异常处理机制可能在某些情况下带来性能开销，同时，异常的使用也会影响程序的流程控制，容易导致难以预料的运行时错误。随着编程实践的发展，开发者们逐渐认识到需要一种更加高效、可预测的方式来表达操作可能的失败情况。

为了弥补这一不足，C++23中引入了`std::expected`这一模板类，作为一种显式的、类型安全的方式来处理可能失败的操作。`std::expected`借鉴了Rust语言中的`Result`类型，它通过拥有两个状态——值（value）和错误（error），来表示一个操作的结果是成功还是失败。

与异常处理相比，使用`std::expected`使得错误处理更加局部化和显式化，它允许函数在有错误发生时返回一个特定的错误类型，而不是抛出一个异常。这样不仅可以保持函数的异常安全保证，还能避免由于异常传播所带来的控制流混乱。

### 3.1.2 expected的类型与构造

`std::expected`是一个包含两种可能状态的模板类，状态可以是：

- `value_type`，操作成功的返回值类型。
- `error_type`，操作失败时的错误类型。

构造`std::expected`对象时，可以采用不同的构造函数来初始化这两种状态。下面是一些典型的构造方法：

#include <expected>
#include <string>

// 构造一个具有值的对象
std::expected<int, std::string> make_expected_value() {
    return std::expected<int, std::string>(42);
}

// 构造一个具有错误的对象
std::expected<int, std::string> make_expected_error() {
    return std::unexpected<std::string>("An error occurred");
}

// 通过值直接构造
std::expected<std::string, int> make_expected_with_direct_value() {
    return std::expected<std::string, int>(std::in_place, "Direct value");
}

// 通过错误直接构造
std::expected<std::string, int> make_expected_with_direct_error() {
    return std::expected<std::string, int>(std::unexpect, 123);
}

在这个例子中，`std::expected<int, std::string>`是一个期望一个`int`类型的值和一个`std::string`