c++协程 | 青训营

用户9888624406161
225 阅读8分钟

当使用C++协程时，有几个关键概念需要理解：

  1. 协程函数（Coroutine Function）：协程函数是使用co_await和co_yield等关键字定义的函数。它可以在执行过程中暂停和恢复，而不会丢失函数的上下文。协程函数可以返回一个值，也可以返回void。
  2. 协程句柄（Coroutine Handle）：协程句柄是对协程函数的实例化对象。通过调用协程句柄的函数调用运算符operator()，可以推进协程函数的执行。
  3. 协程承诺（Coroutine Promise）：协程承诺是协程函数的返回类型。它负责保存协程的状态和返回值，并定义了协程的挂起和恢复行为。
  4. 协程挂起器（Coroutine Suspender）：协程挂起器是协程承诺的成员函数，用于控制协程的挂起和恢复。它们可以返回不同的挂起器类型，例如std::experimental::suspend_always表示总是挂起，std::experimental::suspend_never表示永不挂起。

在使用C++协程时，可以按照以下步骤进行：

  1. 定义协程函数：使用co_await和co_yield等关键字在函数中实现协程逻辑。协程函数可以返回一个值，也可以返回void。例如：
Generator::promise_type myCoroutine() {
    co_yield 1;
    co_yield 2;
    co_yield 3;
}
  1. 创建协程句柄：使用协程函数创建一个协程句柄对象。例如：
auto generator = myCoroutine();
  1. 推进协程执行：通过调用协程句柄的函数调用运算符operator()来推进协程函数的执行。例如：
generator();
  1. 处理协程的返回值或结果：根据协程函数的返回类型，可以使用协程句柄的成员变量或函数来获取协程的返回值或结果。

C++协程提供了一种更简洁、可读性更好的方式来处理异步编程和状态机。它可以帮助开发者更容易地编写并发代码，并提高代码的可维护性。

C++协程是一种轻量级的并发编程技术，可以简化异步编程和状态机的实现。C++20引入了协程支持，通过co_await和co_yield等关键字，可以在函数中实现协程。

下面是一个简单的C++协程示例代码，我们将逐行进行详解：

#include <iostream>
#include <experimental/coroutine>

// 定义一个协程类型
struct Generator {
    struct promise_type {
        int current_value;
        
        // 协程的返回值类型
        int get_return_value() {
            return current_value;
        }
        
        // 创建协程时调用
        auto initial_suspend() {
            return std::experimental::suspend_always{};
        }
        
        // 协程结束时调用
        auto final_suspend() {
            return std::experimental::suspend_always{};
        }
        
        // 协程yield时调用
        auto yield_value(int value) {
            current_value = value;
            return std::experimental::suspend_always{};
        }
        
        // 协程的返回类型
        auto return_void() {
            return std::experimental::suspend_never{};
        }
    };
};

// 协程函数
Generator::promise_type myCoroutine() {
    co_yield 1;
    co_yield 2;
    co_yield 3;
}

int main() {
    auto generator = myCoroutine();
    while (generator.current_value != 3) {
        std::cout << generator.current_value << std::endl;
        generator();
    }
    
    return 0;
}

这段代码演示了一个简单的生成器（Generator）协程。接下来逐行解释：

  1. 引入了<iostream>和<experimental/coroutine>头文件。
  2. 定义了一个名为Generator的结构体，用于表示协程类型。
  3. 在Generator结构体内部定义了一个名为promise_type的结构体。promise_type是协程的承诺类型，用于保存协程的状态和返回值。
  4. 在promise_type结构体中，定义了current_value成员变量，用于保存协程当前的值。
  5. 定义了get_return_value方法，用于获取协程的返回值。
  6. 定义了initial_suspend方法，表示协程初始挂起时的行为。
  7. 定义了final_suspend方法，表示协程结束时的行为。
  8. 定义了yield_value方法，表示协程执行co_yield语句时的行为。
  9. 定义了return_void方法，表示协程返回void时的行为。
  10. 定义了一个名为myCoroutine的协程函数，返回类型为Generator::promise_type。在函数内部使用co_yield语句来产生协程的值。
  11. 在main函数中，创建了一个myCoroutine协程的实例generator。
  12. 使用while循环遍历协程的值，直到协程的当前值为3为止。
  13. 在循环中，打印协程的当前值，并调用generator()来推进协程的执行。
  14. 程序结束后返回0。

这段代码演示了一个简单的C++协程的使用方式。协程通过co_yield语句产生值，并通过调用协程对象的函数调用运算符operator()来推进协程的执行。 当使用C++协程时，可以使用co_await和co_yield关键字来实现协程的挂起和恢复。下面是一个更详细的解释：

  1. co_await关键字：co_await关键字用于在协程函数内部暂停执行，并等待某个异步操作完成。它可以是一个异步任务、一个可等待对象或一个协程句柄。当使用co_await关键字时，协程函数会在此处挂起，并将控制权交给调用者，直到等待的操作完成。例如：
await someAsyncTask();
  1. co_yield关键字：co_yield关键字用于从协程函数中产生一个值，并暂停执行，将该值返回给调用者。协程函数可以在不同的位置使用co_yield关键字来产生多个值。当使用co_yield关键字时，协程函数会在此处挂起，并将控制权交给调用者，直到下一次调用协程函数时恢复执行。例如：
co_yield someValue;
  1. 协程句柄的函数调用运算符：协程句柄对象可以通过调用函数调用运算符operator()来推进协程函数的执行。每次调用协程句柄的函数调用运算符时，协程函数会从上一次挂起的位置继续执行，直到遇到下一次挂起点或协程函数结束。例如：
generator();
  1. 协程的返回值：协程函数可以返回一个值，也可以返回void。如果协程函数返回一个值，则可以使用协程句柄的成员变量来获取返回值。例如：
auto result = generator.current_value;

C++协程提供了一种更简洁、可读性更好的方式来处理异步编程和状态机。使用co_await和co_yield关键字，可以将异步操作和状态迁移的逻辑以更直观的方式表达出来。

当使用C++协程时，可以使用协程承诺（Coroutine Promise）来管理协程的状态和返回值。下面是一个更详细的解释：

  1. 协程承诺（Coroutine Promise）：协程承诺是协程函数的返回类型，它负责保存协程的状态和返回值。协程承诺是一个特殊的结构体，它包含了协程的状态和一些特殊的成员函数，以控制协程的挂起和恢复。协程承诺通常会定义为协程函数的内部类型。例如：
struct promise_type {
    // 协程状态和返回值等成员变量

    // 协程挂起器成员函数
    auto initial_suspend() { return std::experimental::suspend_always{}; }
    auto final_suspend() { return std::experimental::suspend_always{}; }
    void return_void() {}
    // 其他成员函数
};
  1. 协程挂起器（Coroutine Suspender）：协程挂起器是协程承诺的成员函数，用于控制协程的挂起和恢复。协程挂起器可以返回不同的挂起器类型，例如std::experimental::suspend_always表示总是挂起，std::experimental::suspend_never表示永不挂起。通过在协程函数的协程挂起器成员函数中返回适当的挂起器类型，可以控制协程在何时挂起和恢复。例如：
auto initial_suspend() { return std::experimental::suspend_always{}; }
  1. 协程的返回值：协程函数可以返回一个值，也可以返回void。如果协程函数返回一个值，可以在协程承诺中定义一个成员变量来保存返回值，并在协程函数的return_value成员函数中设置返回值。例如：
struct promise_type {
    T result; // 返回值的成员变量

    void return_value(T value) {
        result = value; // 设置返回值
    }
};
  1. 协程句柄的成员变量：协程句柄对象通常会包含一些成员变量，用于保存协程的状态和返回值。可以使用协程句柄的成员变量来获取协程的返回值。例如：
auto result = generator.result;

C++协程的实现可能会有所不同，具体取决于所使用的编译器和标准库版本。上述示例代码是基于C++20中的协程支持

当使用C++协程时，可以使用协程迭代器（Coroutine Iterator）来遍历协程中产生的值。下面是一个更详细的解释：

  1. 协程迭代器（Coroutine Iterator）：协程迭代器是一个特殊的迭代器类型，用于遍历协程函数中产生的值。协程迭代器通常是通过定义一个迭代器结构体，并实现相应的迭代器操作函数来创建的。协程迭代器可以通过重载operator++和operator*等函数，来实现协程的迭代和取值操作。例如：
struct iterator {
    // 迭代器操作函数

    iterator& operator++() {
        // 协程迭代操作
        // ...
        return *this;
    }

    T operator*() {
        // 返回当前迭代器指向的值
        // ...
    }
};
  1. 协程的遍历：通过使用协程迭代器，可以在协程函数外部使用范围for循环或迭代器的方式遍历协程中产生的值。例如：
for (auto value : generator) {
    // 处理每个产生的值
    // ...
}
  1. 协程迭代器的结束标志：协程迭代器通常会定义一个特殊的结束标志，用于表示协程的结束。结束标志可以是一个特殊的迭代器值，或者通过重载operator!=函数来判断是否到达了协程的结束。例如：
bool operator!=(const iterator& other) {
    // 判断是否到达协程的结束
    // ...
}

使用协程迭代器可以方便地遍历协程中产生的值，类似于使用普通的迭代器遍历容器中的元素。这使得协程的使用更加灵活和直观。

avatar
文章
阅读
粉丝