c++20 创建协程

C++20 引入了一种新的语言特性：协程。协程是一种轻量级的、非抢占式的线程，可以实现在同一个线程中切换执行不同的任务，从而避免了线程切换的开销。C++20 中的协程可以通过 co_await 和 co_yield 等关键字来实现。

在 C++20 中创建协程的方式如下：

1. 定义协程函数，使用 co_await 来等待其他协程或异步操作完成：

#include <coroutine>

struct task {
  struct promise_type {
    auto initial_suspend() { return std::suspend_never{}; }
    auto final_suspend() { return std::suspend_never{}; }
    auto get_return_object() { return task{}; }
    void return_void() {}
    void unhandled_exception() {}
  };
};

task foo() {
  std::cout << "start\n";
  co_await std::suspend_always{};
  std::cout << "end\n";
}

int main() {
  foo();
}

2. 使用 co_yield 来暂停当前协程，并返回一个值：

#include <coroutine>
#include <iostream>

struct generator {
  struct promise_type {
    int current_value;
    auto initial_suspend() { return std::suspend_always{}; }
    auto final_suspend() { return std::suspend_always{}; }
    auto get_return_object() { return generator{this}; }
    auto yield_value(int value) {
      current_value = value;
      return std::suspend_always{};
    }
    void return_void() {}
    void unhandled_exception() {}
  };

  generator(promise_type* p) : coro(std::coroutine_handle<promise_type>::from_promise(*p)) {}

  ~generator() {
    if (coro) coro.destroy();
  }

  generator(const generator&) = delete;
  generator& operator=(const generator&) = delete;

  generator(generator&& other) noexcept : coro(other.coro) {
    other.coro = nullptr;
  }

  generator& operator=(generator&& other) noexcept {
    if (this != &other) {
      coro = other.coro;
      other.coro = nullptr;
    }
    return *this;
  }

  int next() {
    coro.resume();
    return coro.promise().current_value;
  }

private:
  std::coroutine_handle<promise_type> coro;
};

generator range(int from, int to) {
  for (int i = from; i < to; ++i) {
    co_yield i;
  }
}

int main() {
  for (auto i : range(0, 5)) {
    std::cout << i << '\n';
  }
}