standrad c++

在 C++20 中，概念（Concepts）被引入为一种强类型约束机制，旨在提高模板代码的可读性、可维护性以及编译错误的诊断质量。概念可以看作是一组类型或值的约束集合，它们通过“约束”语句表达，对模板参数进行检查。下面，我们将从概念的定义、使用、与传统 SFINAE 的比较、以及最佳实践等方面展开讨论。

1. 概念的基本语法

template<typename T>
concept Integral = std::is_integral_v <T>;

template<typename T>
concept Addable = requires(T a, T b) { a + b; };

template<Integral T>
T sum(T a, T b) { return a + b; }

• Integral 定义了一个约束，要求类型 T 必须满足 `std::is_integral_v `。
• Addable 使用 requires 子句检查 T 是否能完成 + 运算。
• 在模板 sum 的参数列表中使用 Integral，这相当于 `requires Integral `。

2. 与传统 SFINAE 的比较

SFINAE（Substitution Failure Is Not An Error）通过使用 std::enable_if 或 decltype 等技巧，在模板参数不满足条件时让该模板被排除。SFINAE 的语法往往冗长，错误信息不够直观：

template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
T sum(T a, T b) { return a + b; }

概念的优点：

• 语义清晰：约束写在模板参数列表中，读者可以一眼看到限制。
• 编译器错误信息友好：如果模板实参不满足概念，编译器会直接指出违反了哪条约束。
• 可组合性强：可以把概念组合成更复杂的约束，例如 `std::integral && std::signed_integral`。

3. 复合概念与自定义约束

template<typename T>
concept SignedIntegral = Integral <T> && std::is_signed_v<T>;

template<concepts::SignedIntegral T>
T clamp(T val, T low, T high) {
    return (val < low) ? low : (val > high) ? high : val;
}

通过复合概念可以将多个简单约束组合成更高层次的抽象，代码更具可读性。

4. 递归约束与模板元编程

概念也能用来控制递归模板实例化的深度或行为。例如实现一个基于递归的 Fold 操作：

template<std::size_t N, typename Func, typename Acc>
constexpr auto fold(Func f, Acc acc) {
    if constexpr (N == 0)
        return acc;
    else
        return fold<N-1>(f, f(acc));
}

这里 if constexpr 结合概念可以让递归停止在编译期，避免过深的实例化。

5. 编译器支持与兼容性

大多数主流编译器（GCC 10+, Clang 10+, MSVC 19.28+）已全面支持 C++20 概念。若需在旧编译器下编译，建议通过宏或条件编译开启或关闭概念相关代码。

6. 典型案例：实现一个泛型 swap

template<typename T>
concept Swappable = requires(T& a, T& b) {
    std::swap(a, b);
};

template<Swappable T>
void genericSwap(T& a, T& b) {
    std::swap(a, b);
}

使用概念后，即使传入不支持 std::swap 的类型，编译器也会给出明确的错误，而不是一堆模板错误。

7. 最佳实践

1. 保持概念简短：每个概念应只描述一个约束，方便复用与组合。
2. 文档化：为每个概念编写注释，说明其目的与适用场景。
3. 使用标准库概念：C++20 标准库已提供大量概念（如 std::integral、std::floating_point），尽量复用。
4. 限制作用域：在需要的头文件中声明概念，避免全局污染。
5. 与 requires 子句结合：对于更细粒度的约束，requires 语句可写在模板内部。

8. 结语

概念的引入让 C++ 模板编程更接近“强类型”的面向对象设计。它既能保持模板的灵活性，又能让类型错误在编译时被清晰地捕获。熟练掌握概念后，你可以写出既简洁又安全的泛型代码，提升整个项目的质量与可维护性。

折叠表达式（fold expressions）是 C++17 引入的一项强大特性，它通过简洁的语法让我们能够在一个可变参数模板（parameter pack）上执行递归或累积运算，而无需显式地展开每一个参数。本文将从理论、实现、性能以及常见使用场景四个维度，对折叠表达式进行深入剖析，并给出一段可直接使用的示例代码。

一、折叠表达式的基本语法

折叠表达式的核心语法形如：

(... op args)   // 左折叠
(args op ...)   // 右折叠
(... op args op ...) // 中折叠

其中 op 可以是任意二元运算符（如 +, *, &&, || 等），args 是一个参数包。C++ 编译器会在编译阶段将这些表达式展开为对应的递归调用，从而在运行时得到预期的结果。

1. 左折叠 vs 右折叠

• 左折叠：先对最左边的元素进行运算，再与下一个元素进行运算。例如 (a + b + c + d) 展开为 (((a + b) + c) + d)。
• 右折叠：先对最右边的元素进行运算，再与前一个元素进行运算。例如 (a + b + c + d) 展开为 (a + (b + (c + d)))。

2. 中折叠

中折叠允许你在两侧都展开，典型的用法是 (... op args op ...)，但在大多数情况下左折叠或右折叠即可满足需求。

二、折叠表达式的实现原理

在编译阶段，折叠表达式的实现实际上是利用模板递归和 std::initializer_list 的折叠机制。以左折叠为例，展开过程类似于：

template<typename... Args>
auto sum(Args... args) {
    return (... + args);
}

编译器会将其内部展开为一个隐式的递归调用链，最终生成一个单一的求和表达式。由于展开是在编译时完成的，运行时不需要额外的循环或递归开销。

三、性能对比

折叠表达式与传统的递归模板或手写循环相比，在大多数情况下具有以下优势：

1. 代码简洁：省去了模板递归结构，代码更易读。
2. 编译器优化：编译器可以更好地进行内联和循环展开。
3. 错误率低：避免了递归模板中的特殊案例（如单参数包的基准情况）。

但需要注意，过度使用折叠表达式（尤其是涉及复杂运算符和大参数包）可能导致编译时间显著增长。最佳实践是将折叠表达式用于参数包尺寸可控且逻辑简单的场景。

四、常见使用场景

1. 可变参数函数的输入验证

   template<typename... Args>
   bool all_positive(Args... args) {
       return (... && (args > 0));
   }

   该函数检查所有参数是否为正数。

2. 字符串拼接

   template<typename... Args>
   std::string concat(const std::string& separator, Args... args) {
       std::ostringstream oss;
       ((oss << args << separator), ...);
       return oss.str();
   }

3. 集合元素的统一处理

   template<typename Func, typename... Args>
   void for_each(Func f, Args&&... args) {
       (f(std::forward <Args>(args)), ...);
   }

4. 求向量或矩阵元素的统计量

   template<typename... Args>
   double average(Args... args) {
       return static_cast <double>((... + args)) / sizeof...(args);
   }

五、完整示例：可变参数日志系统

下面给出一个实际的可变参数日志系统实现，演示折叠表达式在多参数日志记录中的应用。

#include <iostream>
#include <string>
#include <sstream>
#include <chrono>
#include <iomanip>
#include <type_traits>

// 把所有支持 << 的类型转换为字符串
template<typename T>
std::string to_string(const T& val) {
    std::ostringstream oss;
    oss << val;
    return oss.str();
}

// 处理字符串模板的简单占位符替换
std::string format(const std::string& tmpl, const std::initializer_list<std::string>& args) {
    std::string result = tmpl;
    size_t pos = 0;
    for (const auto& arg : args) {
        pos = result.find("{}");
        if (pos == std::string::npos) break;
        result.replace(pos, 2, arg);
    }
    return result;
}

// 日志级别枚举
enum class LogLevel { DEBUG, INFO, WARN, ERROR };

// 主日志函数
template<typename... Args>
void log(LogLevel level, const std::string& tmpl, Args&&... args) {
    // 时间戳
    auto now = std::chrono::system_clock::now();
    auto t = std::chrono::system_clock::to_time_t(now);
    std::tm tm{};
#if defined(_WIN32) || defined(_WIN64)
    localtime_s(&tm, &t);
#else
    localtime_r(&t, &tm);
#endif
    std::ostringstream time_ss;
    time_ss << std::put_time(&tm, "%Y-%m-%d %H:%M:%S");

    // 级别字符串
    std::string level_str;
    switch (level) {
        case LogLevel::DEBUG: level_str = "DEBUG"; break;
        case LogLevel::INFO:  level_str = "INFO";  break;
        case LogLevel::WARN:  level_str = "WARN";  break;
        case LogLevel::ERROR: level_str = "ERROR"; break;
    }

    // 参数转换为字符串列表
    auto args_list = { to_string(std::forward <Args>(args))... };

    // 格式化
    std::string message = format(tmpl, args_list);

    // 输出
    std::cout << "[" << time_ss.str() << "] [" << level_str << "] " << message << std::endl;
}

// 用法示例
int main() {
    log(LogLevel::INFO, "系统启动，内存使用率 {}%", 70);
    log(LogLevel::WARN, "磁盘空间低，剩余 {} GB", 5.4);
    log(LogLevel::ERROR, "文件 {} 打开失败，错误码 {}", "config.cfg", 404);
    return 0;
}

代码说明

• to_string：使用 ostringstream 将任何支持 << 的类型转换为字符串，利用折叠表达式时传入的是原始类型。
• format：非常简易的占位符替换函数，用于演示模板字符串。
• log：核心函数利用折叠表达式 ( ... + args ) 把参数包转换为字符串列表。这里采用的是参数包展开与列表初始化的组合，使得 args_list 里存储的是所有参数对应的字符串表示。
• 在 main 中演示了三种不同级别的日志，参数包可以包含任意数量、任意类型的参数。

六、总结

折叠表达式为 C++17 的模板元编程提供了极大便利，它让可变参数模板的实现更简洁、可读性更高。通过本文的理论解释、实现原理以及实际代码示例，相信读者已能熟练掌握折叠表达式，并在自己的项目中加以运用。未来的 C++20、C++23 里折叠表达式也将继续与更强大的模板特性协同，让可变参数编程更为强大与灵活。

随着 C++17 的发布，std::filesystem 成为 C++ 标准库的一部分，它提供了一套统一且跨平台的文件系统操作接口。相比之前常见的 POSIX API 或 Boost.Filesystem，std::filesystem 在语义上更贴近语言本身，错误处理更加安全，并且与现代 C++ 的异常安全、移动语义完美融合。

1. 为什么要使用 std::filesystem

• 跨平台：同一段代码即可在 Windows、Linux、macOS 等操作系统上编译运行，无需平台特定的预处理宏。
• 异常安全：大部分函数会抛出 std::filesystem::filesystem_error，可以通过捕获异常实现更稳健的错误处理。
• 更简洁的 API：使用 path 对象代替裸字符串，支持链式操作与格式化输出。
• 性能优势：在多数实现中，std::filesystem 采用了系统级别的高效调用（如 GetFileAttributesExW、statx 等），而不是包装旧的 POSIX 代码。

2. 核心概念

名称	作用
std::filesystem::path	表示文件路径，支持拼接、查询文件名、后缀等
std::filesystem::directory_iterator	逐个遍历目录项
std::filesystem::recursive_directory_iterator	递归遍历子目录
std::filesystem::copy_options	指定复制/移动行为（如 overwrite_existing、recursive）
std::filesystem::file_status	文件状态信息（大小、修改时间、权限等）

3. 常见操作示例

3.1 创建、删除和移动文件/目录

#include <filesystem>
namespace fs = std::filesystem;

int main() {
    fs::path dir = "output";
    fs::create_directories(dir);                 // 递归创建
    fs::path file = dir / "example.txt";
    std::ofstream(file) << "Hello, filesystem!"; // 写文件

    fs::path backup = dir / "backup";
    fs::create_directories(backup);
    fs::copy(file, backup / file.filename(), 
             fs::copy_options::overwrite_existing);

    fs::remove(file);                            // 删除文件
    fs::remove_all(backup);                      // 递归删除目录
}

3.2 递归遍历目录并筛选文件

for (const auto& entry : fs::recursive_directory_iterator("src")) {
    if (entry.is_regular_file() && entry.path().extension() == ".cpp") {
        std::cout << "Found C++ source: " << entry.path() << '\n';
    }
}

3.3 检查文件属性

fs::path p = "data.bin";
if (fs::exists(p) && fs::is_regular_file(p)) {
    std::cout << "Size: " << fs::file_size(p) << " bytes\n";
    std::cout << "Last write: " << std::chrono::system_clock::to_time_t(
                     fs::last_write_time(p).time_since_epoch()) << '\n';
}

3.4 错误处理

try {
    fs::create_directory("existing_dir");
} catch (const fs::filesystem_error& e) {
    std::cerr << "Error: " << e.what() << '\n';
    // 可以根据 e.code() 判断错误码
}

4. 与 Boost.Filesystem 的比较

维度	std::filesystem	Boost.Filesystem
标准化	C++17 之后已标准化	仍是第三方库
依赖	无外部依赖	需要 Boost 依赖
头文件	`
|`
异常	filesystem_error	boost::filesystem::filesystem_error
未来	与编译器实现紧密	仍保持兼容性，但发展受限

5. 实践建议

1. 避免裸字符串：始终使用 fs::path 对象进行路径操作。
2. 错误码模式：在性能敏感场景，使用 std::error_code 而不是异常，避免异常开销。
3. 跨平台测试：即使只在 Windows 上开发，也建议在 Linux / macOS 上编译运行一次，验证路径分隔符、权限等差异。
4. 保持代码简洁：链式调用 path 的成员函数，能让代码更易读。

6. 结语

std::filesystem 的加入，让 C++ 的文件系统操作不再是“低层、繁琐、易错”的痛点。无论是简单的文件复制，还是复杂的项目构建系统，都能通过标准库一次性覆盖。掌握它，能让你在 C++ 开发中更专注于业务逻辑，而不是琐碎的系统细节。

在 C++20 之前，处理数组、向量以及其它容器的子序列通常需要自己实现切片逻辑，或者使用标准库提供的 std::array、std::vector 等，并通过 begin()/end() 等方法手动获取迭代器。
C++20 引入的 std::span（在 <span> 头文件中定义）为这类工作提供了一种轻量级、无所有权的视图（view）。std::span 不是容器，它只保存一个指向元素的指针和一个长度，不能修改其所指向的数据的大小，只能访问。

1. std::span 的基本定义

template<class T, std::size_t Extent = std::dynamic_extent>
class span;

• T 是元素类型。
• Extent 是元素数量，若未知可用 std::dynamic_extent。

2. 如何构造 std::span

int arr[5] = {1, 2, 3, 4, 5};
std::span <int> sp1(arr);                    // 整个数组
std::span <int> sp2(arr, 3);                 // 前 3 个元素
std::span <int> sp3(arr + 1, 3);             // 从 arr[1] 开始的 3 个元素

`std::vector

vec = {10, 20, 30, 40};` `std::span sp4(vec);` // 直接使用容器，span 会调用 `data()` 与 `size()`。 ### 3. 常用成员函数 | 成员 | 说明 | |——|——| | `size()` | 返回元素数量 | | `data()` | 返回指向首元素的指针 | | `empty()` | 判断是否为空 | | `operator[]` | 访问指定下标 | | `front()`, `back()` | 访问首尾元素 | | `subspan(n)` | 从第 n 个元素开始的子 span | | `last(n)` | 末尾 n 个元素的子 span | | `first(n)` | 开始 n 个元素的子 span | ### 4. 与容器迭代器的兼容 `std::span` 的 `begin()` 与 `end()` 返回原始指针，可直接用于范围-based for 循环。 “`cpp for (int x : sp1) std::cout sp = std::span(new int[10], 10); // 错误：sp 只是一视图，未负责释放内存 “` 建议只在栈上或已有容器的数据上创建 `span`，不用于动态分配。 ### 6. 典型使用场景 * **函数参数**： “`cpp void process(std::span data) { // 对 data 做处理，读写都可以 } “` 这样函数既可以接受数组、向量，也能接受子序列。 * **子序列访问**： “`cpp void print_first_half(std::span arr) { auto half = arr.first(arr.size() / 2); for (int v : half) std::cout ` 将任意对象序列化为字节流。 ### 9. 示例代码：排序子范围 下面演示如何用 `std::span` 对向量的一部分进行排序，而不影响其它部分。 “`cpp #include #include #include #include void sort_subrange(std::vector & v, std::size_t lo, std::size_t hi) { std::span sub(v.data() + lo, hi – lo); // 只看 [lo, hi) std::sort(sub.begin(), sub.end()); } int main() { std::vector numbers = {9, 1, 4, 7, 3, 8, 2, 5, 6}; std::cout

在现代 C++ 开发中，错误处理往往需要在保持代码可读性和安全性的前提下提供足够的信息。传统的做法是返回错误码、使用异常或者采用输出参数。随着 C++17 标准引入 std::optional，一种更简洁、类型安全且无需异常的错误处理方案开始受到关注。本文将从语义、实现细节、典型场景和性能影响四个方面，深入剖析 std::optional 在错误处理中的应用。

1. 语义与核心思想

`std::optional

` 本质上是一个可能包含 `T` 或者不包含任何值的容器。它的存在意味着“有值”与“无值”是同一类型的一部分，而不是通过特殊返回值或错误码来区分。 在错误处理时，若函数可能失败或没有结果，返回 `std::optional ` 能明确表示： – **成功**：`std::optional` 持有有效的 `T`，访问 `value()` 或解包即可得到结果。 – **失败**：`std::optional` 为空，调用者可以使用 `has_value()` 检查，或直接进行 `if (opt)` 语句。 相比异常，`std::optional` 避免了堆栈展开的成本；相比错误码，减少了被忽略的风险。 ### 2. 常见使用模式 | 场景 | 示例代码 | |——|———-| | 读取文件行 | `std::optional readLine(std::istream& in);` | | 查找容器元素 | `std::optional findIf(std::vector& v, Predicate p);` | | 解析字符串为数值 | `std::optional tryParseInt(const std::string& s);` | **实现建议** – **返回类型**：`std::optional ` 或 `std::optional>`（用于返回引用）。 – **异常抛出**：除非必须处理资源管理问题，通常避免在 `optional` 中抛异常。 – **默认值**：若业务逻辑允许默认值，可提供 `value_or(default)`。 ### 3. 与其他错误处理机制的互补 | 机制 | 优点 | 缺点 | 适用场景 | |——|——|——|———-| | `std::optional` | 轻量、无异常、明确语义 | 无错误信息，需自行记录 | 需要区分成功/失败但错误信息不重要的情况 | | 异常 | 传递完整错误信息 | 性能开销、堆栈展开 | 复杂错误、资源回收、跨层抛错 | | 错误码 | 轻量、无异常 | 容易被忽视、缺乏可读性 | 性能敏感、嵌入式系统 | 在实际项目中，可以将 `std::optional` 与错误码或异常配合使用，例如： “`cpp std::optional readLine(std::istream& in) { std::string line; if (!std::getline(in, line)) { return std::nullopt; // 读取失败 } return line; // 成功 } “` 调用者可进一步结合 `std::variant` 来提供错误细节。 ### 4. 性能考量 – **内存占用**：`std::optional ` 在编译器支持的情况下通常实现为 `T` 与一个布尔标志，大小为 `sizeof(T) + 1`（对齐后）。 – **复制/移动**：若 `T` 支持移动构造，`std::optional ` 的移动成本与 `T` 本身相当。 – **空值检查**：`has_value()` 本质上是读取一个布尔字段，几乎无成本。 与返回指针相比，`std::optional` 更加类型安全；与返回错误码相比，它避免了多次返回值的混淆。 ### 5. 小结 – `std::optional` 为错误处理提供了一个既安全又简洁的方式。 – 它最适合在不需要传递错误细节的情况下，明确表达“可能成功也可能失败”。 – 与异常、错误码等机制结合使用，可以在保证可读性和性能的前提下，构建健壮的 C++ 系统。 在日益复杂的 C++ 生态中，学会合理运用 `std::optional` 将帮助你写出更易维护、错误更少的代码。

在 C++17 标准中，std::optional 为我们提供了一种优雅且类型安全的方式来表示“可能存在也可能不存在”的值。与传统的返回指针、状态码或异常相比，std::optional 可以更直观地表达函数的意图，并且在编译时帮助我们避免一些常见错误。下面我们通过一个实际案例，演示如何使用 std::optional 来实现错误处理，并讨论其优点与局限。

1. 需求场景

假设我们正在开发一个小型的配置管理库，ConfigLoader 负责读取配置文件并返回配置值。配置文件中可能不存在某个键，这时我们希望返回“未找到”的信息，而不是抛异常或返回空字符串。我们也希望调用者能够明确判断是否获取到有效值。

2. 代码实现

#include <iostream>
#include <fstream>
#include <sstream>
#include <unordered_map>
#include <optional>
#include <string>
#include <cctype>

// 简单的 key=value 解析器
class ConfigLoader {
public:
    explicit ConfigLoader(const std::string& filename) {
        std::ifstream fin(filename);
        if (!fin) {
            throw std::runtime_error("无法打开配置文件: " + filename);
        }
        std::string line;
        while (std::getline(fin, line)) {
            trim(line);
            if (line.empty() || line[0] == '#')
                continue;
            auto pos = line.find('=');
            if (pos == std::string::npos) continue;
            std::string key = line.substr(0, pos);
            std::string value = line.substr(pos + 1);
            trim(key);
            trim(value);
            config_[key] = value;
        }
    }

    // 返回 std::optional<std::string>
    std::optional<std::string> get(const std::string& key) const {
        auto it = config_.find(key);
        if (it != config_.end())
            return it->second;
        return std::nullopt;               // 关键：返回空 optional
    }

private:
    std::unordered_map<std::string, std::string> config_;

    // 去除前后空格
    static void trim(std::string& s) {
        const char* ws = " \t\n\r";
        s.erase(0, s.find_first_not_of(ws));
        s.erase(s.find_last_not_of(ws) + 1);
    }
};

3. 使用示例

int main() {
    try {
        ConfigLoader loader("app.conf");

        // 正常取值
        if (auto val = loader.get("database.host"); val) {
            std::cout << "数据库主机: " << *val << '\n';
        } else {
            std::cout << "未配置数据库主机\n";
        }

        // 错误取值
        if (auto val = loader.get("missing.key"); val) {
            std::cout << "存在值: " << *val << '\n';
        } else {
            std::cout << "missing.key 未配置\n";
        }
    } catch (const std::exception& e) {
        std::cerr << "错误: " << e.what() << '\n';
        return 1;
    }
    return 0;
}

运行结果（假设 app.conf 包含 database.host=localhost）：

数据库主机: localhost
missing.key 未配置

4. 优点解析

1. 显式意图
   std::optional 的使用让函数返回值的语义非常清晰：要么存在有效数据，要么没有。相比返回空字符串或特殊值，语义更直观。

2. 避免未定义行为
   通过 if (auto val = loader.get("key"); val) 可以安全检查是否存在值，避免对空指针或无效引用解引用。

3. 编译期检查
   std::optional 在编译期强制要求访问者使用 operator* 或 value() 等安全方式获取内容，减少了运行时错误。

4. 轻量级
   std::optional 通常实现为值对象（包含一个 bool + 对齐后的值），内存占用与原始类型相当，不会引入额外的堆分配。

5. 局限与注意事项

• 不可复制或不可移动的类型
  如果返回类型不满足 CopyConstructible 或 MoveConstructible，则 std::optional 可能无法使用。此时需要自定义包装或使用 std::variant。

• 与异常结合
  std::optional 并不适合表示错误码或异常信息。它仅用于“值/无值”的情况。对于真正的错误处理，仍然推荐使用异常或错误码。

• 与函数链
  在链式调用中使用 std::optional 可能导致阅读困难，需要使用 std::optional 的 and_then、transform 等方法（C++23 之后）或者手写 if 语句。

6. 小结

std::optional 为 C++ 提供了一种简洁、安全的方式来表示“可选值”。在配置读取、查找表、缓存等多种场景中，它都能显著提升代码可读性和健壮性。通过本文示例，你应该已经掌握了如何在实际项目中使用 std::optional 来实现错误处理，并了解了它的优点与适用范围。祝你编码愉快！

在现代C++中，协程（coroutine）为我们提供了一种简洁而强大的方式来编写异步、事件驱动或并发代码。自C++20起，协程被正式纳入标准库，配合std::generator、std::task、std::suspend_always等辅助类，让异步编程更像同步代码。本文将深入剖析协程的工作原理、关键概念以及实际使用技巧，并通过示例代码展示如何在C++20项目中实现异步任务。

1. 协程的基本概念

• 协程函数：一种特殊的函数，它可以在执行过程中被挂起和恢复。协程函数的声明需要返回类型为std::experimental::coroutine_handle相关的类型，例如std::future, std::generator等。
• 挂起点：协程内部使用co_await, co_yield或co_return语句触发挂起。挂起时，协程的局部状态会被保存，直到下次恢复。
• 协程句柄：coroutine_handle是对协程实例的可操作句柄，负责调度协程的执行和销毁。

2. 关键实现细节

2.1 协程的状态机

编译器会把协程函数编译成一个状态机。每个挂起点对应一个状态值，协程在恢复时根据当前状态决定执行哪一段代码。

2.2 协程框架中的promise_type

每个协程都有一个与之关联的promise_type。它是协程的“宿主”，负责提供协程的返回值、异常处理以及挂起点的行为。promise_type需要实现以下成员：

• get_return_object()
• initial_suspend()
• final_suspend()
• return_value(T)
• unhandled_exception()

2.3 co_await、co_yield和co_return

• co_await expr：等待expr的完成。expr必须返回一个可 awaitable 的对象。
• co_yield expr：生成一个值并挂起协程，等待下一个 co_yield 或外部调用。
• co_return expr：结束协程，返回最终值。

3. 常用协程包装

3.1 std::generator

std::generator <int> count_up_to(int n) {
    for (int i = 1; i <= n; ++i)
        co_yield i;
}

3.2 std::task（自定义）

标准库中并未直接提供task，但可以自定义一个类似于std::future的协程返回类型。

struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::rethrow_exception(std::current_exception()); }
    };
};

4. 示例：异步下载文件

下面演示如何使用协程实现一个简单的异步下载器。我们将使用cppcoro::async_http_client（第三方库）来演示协程与网络 I/O 的结合。

#include <cppcoro/async_task.hpp>
#include <cppcoro/sync_wait.hpp>
#include <cppcoro/async_pipe.hpp>
#include <cppcoro/http_client.hpp>
#include <filesystem>
#include <fstream>
#include <iostream>

namespace fs = std::filesystem;

cppcoro::async_task <void> download_file(const std::string& url, const fs::path& out_path) {
    cppcoro::http_client client(url);
    co_await client.send_request(cppcoro::http::verb::get);

    std::ofstream ofs(out_path, std::ios::binary);
    if (!ofs.is_open()) {
        std::cerr << "Failed to open output file.\n";
        co_return;
    }

    auto stream = client.body_stream();
    while (auto chunk = co_await stream.next()) {
        ofs.write(chunk.data(), chunk.size());
    }

    std::cout << "Download completed: " << out_path << "\n";
}

int main() {
    cppcoro::sync_wait(download_file("https://example.com/file.bin", "file.bin"));
}

说明

• `cppcoro::async_task ` 是一个协程返回类型，类似于 `std::future`。
• co_await client.send_request(...) 让协程挂起，等待 HTTP 请求完成。
• stream.next() 挂起直到下一个数据块可用，实现流式读取。

5. 常见陷阱与调试技巧

1. 忘记 initial_suspend 或 final_suspend：如果返回 std::suspend_always，协程会在创建时立即挂起，需要手动调用 handle.resume()。
2. 异常泄露：promise_type::unhandled_exception() 必须处理异常，否则会导致未定义行为。
3. 资源泄漏：协程结束前请确保所有资源（如文件句柄、网络连接）已释放。
4. 调试工具：IDE 里可以通过设置断点在 co_await 行查看挂起点；或者使用 std::experimental::coroutine_traits 打印状态机信息。

6. 性能考量

• 协程的开销：与传统回调相比，协程的上下文切换更轻量，且避免了大量堆分配。
• 内存占用：协程的局部变量会在协程框架中存储；如果变量很大，考虑使用 std::shared_ptr 或 std::unique_ptr。
• 与线程池结合：可以将协程与线程池（如 cppcoro::io_context）结合，让 I/O 任务在后台线程上运行。

7. 结语

C++20 的协程为我们提供了一种与同步代码风格相近、易于维护的异步编程方式。通过理解其背后的状态机、promise_type 以及挂起点，开发者可以在不牺牲性能的前提下实现复杂的异步逻辑。未来的标准库（C++23 之后）将进一步完善协程相关工具，如 std::generator、std::task 等，让协程生态更加完整。掌握这些技术，您将能在网络编程、游戏开发、金融交易等领域写出更高效、可读性更好的代码。

协程（Coroutine）是一种轻量级的用户级线程，它可以在函数内部暂停执行并在后续恢复，从而实现异步编程、事件驱动和并发控制等功能。C++20 标准中引入了原生协程（co_await、co_yield、co_return）支持，使得协程的使用变得更直观。本文将从原理、实现细节以及一个完整的协程例子三部分来剖析如何在 C++ 中使用协程。

一、协程的基本原理

1. 挂起与恢复

   • 当协程执行到 co_await、co_yield 或 co_return 时会“挂起”，把当前执行状态（寄存器、栈帧、局部变量等）保存下来，随后返回控制权给调用者。
   • 当协程再次被调度（通常是通过 resume()）时，会恢复之前保存的状态，从挂起点继续执行。

2. 协程句柄（std::coroutine_handle）

   • 句柄是协程的管理对象，负责启动、挂起、恢复、销毁协程。
   • 通过 coroutine_handle::from_promise(promise) 可以从协程的 promise_type 获得句柄。

3. 协程的 Promise 对象

   • 每个协程都有一个 promise_type，负责协程的生命周期管理。
   • promise_type 必须实现若干接口，如 get_return_object()、initial_suspend()、final_suspend()、return_void() 或 return_value() 等。

二、C++20 协程的实现细节

1. promise_type 必须实现的成员

成员函数	说明
get_return_object()	返回协程可被外部使用的对象，通常返回 `std::coroutine_handle
` 或自定义包装类型
initial_suspend()	决定协程在起始时是否立即挂起，返回 std::suspend_always 或 std::suspend_never
final_suspend()	决定协程在完成时是否挂起，返回 std::suspend_always 或 std::suspend_never
return_void() / return_value(T)	处理协程的返回值
unhandled_exception()	处理协程中抛出的异常
yield_value(T)	处理 co_yield 的值，返回 std::suspend_always 或 std::suspend_never

2. co_await 与 Awaitable 对象

当协程执行 co_await expr 时，编译器会尝试将 expr 转换为 Awaitable 类型。Awaitable 必须至少实现：

成员	说明
await_ready()	若立即可完成则返回 true
await_suspend(coroutine_handle)	若需要挂起则返回 true，并保存协程句柄以供后续恢复
await_resume()	在协程恢复后返回值

3. 资源管理

协程的堆栈是由编译器自动管理的，但协程内部所分配的资源（如文件句柄、网络连接）需要在 final_suspend() 或 return_value() 中手动释放。常用做法是将资源包装在 RAII 对象里，确保在协程结束时自动析构。

三、完整示例：异步文件读取协程

下面给出一个使用标准库实现的简单异步文件读取协程示例，演示如何使用 co_await 读取文件块并逐块处理。

#include <coroutine>
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <optional>
#include <thread>
#include <chrono>

// Awaitable：模拟异步读取
struct AsyncRead {
    std::ifstream &file;
    std::size_t size;
    std::vector <char> buffer;
    std::coroutine_handle<> caller; // 被挂起的协程句柄

    AsyncRead(std::ifstream &f, std::size_t sz)
        : file(f), size(sz), buffer(sz) {}

    bool await_ready() const noexcept { return false; }

    void await_suspend(std::coroutine_handle<> h) {
        caller = h;
        // 异步读取（这里用线程模拟）
        std::thread([this]() {
            file.read(buffer.data(), size);
            std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟延迟
            caller.resume(); // 读取完成后恢复协程
        }).detach();
    }

    std::optional<std::vector<char>> await_resume() noexcept {
        if (file.gcount() == 0) return std::nullopt;
        return buffer;
    }
};

// 协程函数：读取文件并打印
std::coroutine_handle<> read_file_async(const std::string &path) {
    std::ifstream file(path, std::ios::binary);
    if (!file) {
        std::cerr << "Failed to open file.\n";
        co_return;
    }

    while (true) {
        auto chunk_opt = co_await AsyncRead(file, 1024);
        if (!chunk_opt) break; // EOF
        const auto &chunk = *chunk_opt;
        std::cout.write(chunk.data(), file.gcount());
    }
    co_return;
}

int main() {
    auto handle = read_file_async("sample.bin");
    handle.resume(); // 开始执行
    // 在此可做其他工作，协程会在后台异步完成
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 0;
}

代码说明

1. AsyncRead

   • await_ready() 始终返回 false，表示需要挂起。
   • await_suspend() 启动一个新线程模拟异步读取，并在读取完成后调用 caller.resume()。
   • await_resume() 将读取到的数据返回给协程。

2. read_file_async

   • 通过 co_await AsyncRead 挂起等待文件块，读取完成后继续。
   • co_return 在文件结束后终止协程。

3. 主函数

   • 调用 read_file_async 得到协程句柄并立即 resume()，随后主线程可以继续执行其他任务。

四、总结

• C++20 原生协程为异步编程提供了更轻量、更易读的实现方式。
• 关键是理解协程的挂起/恢复、promise_type、以及 Awaitable 的三个接口。
• 在实际项目中，可以将协程与 I/O 框架（如 Boost.Asio、libuv）结合，进一步提升性能。

通过上述原理解析与完整示例，相信你已经可以在自己的 C++ 项目中自由使用协程，实现更高效、可读性更好的异步代码。

C++20 推出了模块化（Modules）特性，旨在解决传统头文件的编译耦合问题。下面将通过一个完整的示例，演示如何定义、使用以及编译一个简单的模块，并结合常见的构建工具展示实战流程。

1. 目录结构

module_demo/
├─ src/
│  ├─ math.ixx          // 模块接口
│  ├─ math_impl.cpp     // 模块实现
│  ├─ main.cpp
├─ build/
├─ CMakeLists.txt

2. math.ixx – 模块接口文件

#pragma once

module math;

export module math;

export namespace Math {
    // 计算整数的阶乘
    int factorial(int n);
}

3. math_impl.cpp – 模块实现文件

module math;

#include <stdexcept>

namespace Math {
    int factorial(int n) {
        if (n < 0) throw std::invalid_argument("n must be non-negative");
        return (n <= 1) ? 1 : n * factorial(n - 1);
    }
}

注意：在实现文件中不需要 export，只在接口文件中使用 export 声明外部可见的符号。

4. main.cpp – 使用模块的程序

import math;          // 引入模块

#include <iostream>

int main() {
    for (int i = 0; i <= 5; ++i) {
        std::cout << i << "! = " << Math::factorial(i) << '\n';
    }
    return 0;
}

5. CMakeLists.txt – 构建配置

cmake_minimum_required(VERSION 3.23)   # 需支持 C++20 模块
project(ModuleDemo LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# 编译选项
add_compile_options(-fmodules-ts -fimplicit-inline-templates)

# 生成模块
add_library(math MODULE src/math.ixx src/math_impl.cpp)

# 把模块导出到全局可见目录
target_compile_options(math PRIVATE -fmodules-ts)
target_link_options(math PRIVATE -fmodules-ts)

# 可执行文件
add_executable(module_demo src/main.cpp)
target_link_libraries(module_demo PRIVATE math)

说明

• -fmodules-ts 是 GCC/Clang 对模块技术规范（TS）的实现开关；在较新的版本已默认开启。
• MODULE 关键字创建一个模块化目标。

6. 编译运行

mkdir build && cd build
cmake ..
cmake --build .
./module_demo

输出：

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120

7. 常见问题解答

问题	解决方案
编译器报错 error: cannot load module interface	确认 CMakeLists.txt 中使用了 MODULE 而不是 STATIC 或 SHARED。
模块在不同编译单元中重复定义	确保只在 .ixx 接口文件中使用 export，实现文件不重复导出。
头文件与模块混用导致编译时间反而变长	彻底替换为模块化；若仍需头文件，可使用 -fno-implicit-modules。

8. 小结

通过上述步骤，你可以在 C++20 环境下完整地实现并使用模块。模块化带来的优势包括：

• 编译速度提升：避免重复解析头文件。
• 符号可见性更精确：只导出 export 的符号。
• 更好的语言集成：模块可以与 C++ 标准库、第三方库无缝协作。

掌握模块化是迈向现代 C++ 的关键一步，建议在新项目中优先考虑使用。

在 C++17 中，std::variant 被引入为一种类型安全的联合体实现。它允许在同一个对象中存放多种不同类型之一，并且能够在编译时保证类型安全。本文将从基本概念、典型用法、访问方式、转换与匹配以及性能考虑等方面，全面介绍 std::variant 的使用。

1. 什么是 std::variant

std::variant<T1, T2, …, TN> 是一个变体类型，内部保持着 N 种可能的类型之一。与传统的 C 语言 union 不同，std::variant 具备：

• 类型安全：只能存放预定义的类型之一。
• 异常安全：在构造、赋值过程中会自动进行异常处理。
• 值语义：支持拷贝、移动、赋值等操作。

2. 基本使用

#include <variant>
#include <iostream>
#include <string>

using Variant = std::variant<int, double, std::string>;

int main() {
    Variant v1 = 42;          // int
    Variant v2 = 3.14;        // double
    Variant v3 = std::string("hello");

    std::cout << std::get<int>(v1) << '\n';   // 42
    std::cout << std::get<double>(v2) << '\n'; // 3.14
    std::cout << std::get<std::string>(v3) << '\n'; // hello
}

2.1 默认构造与初始化

• 如果首个类型支持默认构造，则 Variant{} 默认构造为该类型。
• 否则必须显式提供初始值。

Variant v{};               // 如果 int 是首个类型且默认构造
Variant v{std::in_place_index <2>, "world"}; // 指定索引构造
Variant v{std::in_place_type<std::string>, "world"}; // 指定类型构造

2.2 访问方式

• `std::get (v)`：若当前类型不是 `T`，则抛出 `std::bad_variant_access`。
• std::get <I>(v)：按索引访问。
• `std::get_if (&v)` / `std::get_if(&v)`：返回指针，若类型不匹配则返回 `nullptr`。

3. 访问多种类型的技巧

3.1 std::visit

std::visit 结合 std::variant 允许对存储的值进行访问而不必先判断类型。

struct Printer {
    void operator()(int i) const { std::cout << "int: " << i << '\n'; }
    void operator()(double d) const { std::cout << "double: " << d << '\n'; }
    void operator()(const std::string& s) const { std::cout << "string: " << s << '\n'; }
};

Variant v = "example";
std::visit(Printer{}, v);  // 输出 string: example

可以使用 auto 的 lambda 表达式来简化：

std::visit([](auto&& arg) {
    std::cout << "value: " << arg << '\n';
}, v);

3.2 std::holds_alternative

检测当前值是否为某类型：

if (std::holds_alternative <int>(v)) {
    // 处理 int
}

4. 典型场景

4.1 表示多种返回值

std::variant<int, std::string> parse(const std::string& input) {
    try {
        int n = std::stoi(input);
        return n;
    } catch (...) {
        return std::string("invalid");
    }
}

4.2 事件系统

struct ClickEvent { int x, y; };
struct KeyEvent { char key; };
using Event = std::variant<ClickEvent, KeyEvent>;

void handle(Event e) {
    std::visit([](auto&& ev){
        using T = std::decay_t<decltype(ev)>;
        if constexpr (std::is_same_v<T, ClickEvent>) {
            std::cout << "Click at (" << ev.x << ',' << ev.y << ")\n";
        } else if constexpr (std::is_same_v<T, KeyEvent>) {
            std::cout << "Key pressed: " << ev.key << '\n';
        }
    }, e);
}

5. 性能与实现细节

• 大小：std::variant 的大小等于最大成员类型的大小加上足够存储索引的空间。
• 构造与赋值：采用完美转发，避免不必要的拷贝。
• 与 std::optional 的区别：std::variant 可存储多种类型，而 std::optional 只能表示某类型的缺失。

6. 常见错误与调试技巧

1. **使用 `std::get

   ` 时忘记类型检查** – 建议先使用 `std::holds_alternative ` 或 `std::get_if`。

2. 索引错误

   • std::visit 中访问时使用 auto lambda 可以避免索引错误。

3. 移动语义不充分

   • 对于大对象，使用 std::in_place_type 或 std::move 构造可提升效率。

7. 进阶使用：自定义 visitor

template<class... Ts>
struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...)->overloaded<Ts...>;

std::visit(overloaded{
    [](int i){ std::cout << "int: " << i << '\n'; },
    [](double d){ std::cout << "double: " << d << '\n'; },
    [](const std::string& s){ std::cout << "string: " << s << '\n'; }
}, v);

8. 小结

std::variant 让 C++ 程序员可以在保持类型安全的前提下，优雅地处理多种可能的值。它与 std::visit 的组合提供了类似模式匹配的功能，使代码更加简洁和可维护。随着 C++20 之后 std::variant 的功能进一步完善（如 std::visit 的简化、std::monostate 等），其在实际项目中的应用将会越来越广泛。

练习
试着实现一个“属性容器”，能够存放 int、double、std::string、bool 四种类型的属性，并支持通过属性名获取值。你可以使用 std::unordered_map<std::string, std::variant<...>> 结构，配合 std::visit 进行类型安全访问。祝编码愉快！