C++20协程怎么用？机制与示例详解

#include <iostream>
#include <coroutine>
#include <vector>

struct Generator {
    struct promise_type {
        int current_value;

        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        Generator get_return_object() {
            return Generator(std::coroutine_handle<promise_type>::from_promise(*this));
        }

        void return_void() {}

        std::suspend_always yield_value(int value) {
            current_value = value;
            return {};
        }

        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle;

    explicit Generator(std::coroutine_handle<promise_type> h) : handle(h) {}

    ~Generator() {
        if (handle) handle.destroy();
    }

    int value() const { return handle.promise().current_value; }

    bool move_next() {
        if (!handle.done())
            handle.resume();
        return !handle.done();
    }
};

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

int main() {
    auto gen = range(1, 6);
    while (gen.move_next()) {
        std::cout << gen.value() << ' ';
    }
    // 输出: 1 2 3 4 5
}

#include <iostream>
#include <coroutine>
#include <thread>
#include <chrono>

struct Awaiter {
    bool await_ready() { return false; } // 总是挂起

    void await_suspend(std::coroutine_handle<> h) {
        std::thread([h]() mutable {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            h.resume(); // 1秒后恢复
        }).detach();
    }

    void await_resume() {}
};

struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
};

Task async_work() {
    std::cout << "开始异步工作...\n";
    co_await Awaiter{};
    std::cout << "工作完成!\n";
}

int main() {
    async_work();
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 等待完成
}