C++20 协程：异步编程的新纪元

C++20 引入了协程（coroutines），这是一种全新的异步编程模型，使得编写异步代码变得更加简洁和直观。本文将详细介绍 C++20 协程的概念、功能演变及其在实际项目中的应用。通过本文，你将了解到协程的基本原理、语法和如何利用协程来简化异步编程。

1. 协程的概念

协程（coroutine） 是一种可以暂停执行的函数，它可以在执行过程中挂起（yield）并恢复执行。与传统的函数不同，协程可以在执行过程中多次进出，从而实现更高效的异步编程。

2. 功能演变

2.1 早期尝试

Boost.Coroutine：Boost 库早在 C++11 之前就提供了协程的支持。它通过底层的上下文切换来实现协程的功能。
P0333R11：C++ 标准委员会提出了一个关于协程的设计提案，最终在 C++20 中被采纳。

2.2 C++20 标准

co_await：用于等待一个协程表达式的结果。
co_yield：用于产生一个值，并暂时挂起协程。
co_return：用于从协程返回一个值。

3. C++20 协程的基本语法

3.1 协程函数

协程函数可以通过在返回类型前加上 -> 和 std::suspend_never、std::suspend_always 或 std::suspend_never 来声明。

std::suspend_never：表示协程不会挂起。
std::suspend_always：表示协程总是挂起。
std::suspend_also：表示协程可能挂起也可能不挂起。

// 一个简单的协程函数
struct SimpleCoroutine {
    int operator()(int x) -> std::suspend_never {
        co_yield x * 2;
        co_return;
    }
};

int main() {
    SimpleCoroutine coro;
    auto result = coro(5); // 10
}

3.2 协程控制块

协程控制块（coroutine handle）用于管理协程的生命周期。

// 创建协程控制块
struct Coroutine {
    struct promise_type {
        int value;
        
        // 构造函数
        promise_type(int val) : value(val) {}

        // get_return_object
        auto get_return_object() {
            return *this;
        }

        // initial_suspend
        std::suspend_never initial_suspend() {}

        // final_suspend
        std::suspend_never final_suspend() noexcept {}

        // return
        void return_value(int val) {}

        // unhandled_exception
        void unhandled_exception() {}
    };

    coroutine_handle<promise_type> handle;

    Coroutine(coroutine_handle<promise_type> h) : handle(h) {}

    // 启动协程
    void start() {
        if (!handle.done()) {
            handle.resume();
        }
    }

    // 挂起协程
    void suspend() {
        if (!handle.done()) {
            handle.promise().value = 42;
            handle.suspend();
        }
    }

    // 等待协程
    int await() {
        if (!handle.done()) {
            handle.resume();
        }
        return handle.promise().value;
    }
};

// 使用协程
Coroutine::promise_type::value = 10;
Coroutine coro(Coroutine::promise_type::make_promise());
coro.start();
int result = coro.await(); // 42

4. 实战应用

4.1 异步 I/O

协程非常适合用于异步 I/O 操作。下面是一个简单的异步文件读取示例：

#include <iostream>
#include <fstream>
#include <coroutine>

struct AsyncFileReader {
    struct promise_type {
        std::string filename;
        std::ifstream file;
        std::string buffer;

        // get_return_object
        AsyncFileReader get_return_object() {
            return *this;
        }

        // initial_suspend
        std::suspend_never initial_suspend() {}

        // final_suspend
        std::suspend_never final_suspend() noexcept {}

        // return
        void return_value(std::string buf) {
            buffer = std::move(buf);
        }

        // unhandled_exception
        void unhandled_exception() {}

        void read_file() {
            file.open(filename);
            if (file.is_open()) {
                std::getline(file, buffer);
                co_return buffer;
            } else {
                co_return "";
            }
        }
    };

    coroutine_handle<promise_type> handle;

    AsyncFileReader(coroutine_handle<promise_type> h) : handle(h) {}

    std::string await_resume() {
        handle.resume();
        return handle.promise().buffer;
    }
};

AsyncFileReader async_read_file(std::string filename) {
    return AsyncFileReader{coroutine_handle<promise_type>::from_promise(promise_type{filename})};
}

int main() {
    auto result = async_read_file("example.txt").await_resume();
    std::cout << "Read data: " << result << std::endl;
}

4.2 异步网络编程

协程也非常适合用于异步网络编程。下面是一个简单的异步 HTTP 请求示例：

#include <iostream>
#include <coroutine>
#include <asio/awaitable.hpp>
#include <asio/io_context.hpp>
#include <asio/ip/tcp.hpp>
#include <asio/steady_timer.hpp>
#include <asio/co_spawn.hpp>

using namespace asio::awaitable;

struct HttpClient {
    asio::io_context& io;
    asio::ip::tcp::socket socket;

    HttpClient(asio::io_context& io) : io(io), socket(io) {}

    void connect(const std::string& host, const std::string& port) {
        asio::connect(socket, asio::ip::tcp::resolver(io).resolve(host, port));
    }

    std::string send_request(const std::string& request) {
        asio::write(socket, asio::buffer(request));
        asio::streambuf response_buffer;
        asio::read_until(socket, response_buffer, "\r\n\r\n");
        return asio::buffer_cast<const char*>(response_buffer.data());
    }
};

struct AsyncHttpClient {
    asio::io_context& io;
    HttpClient client;

    AsyncHttpClient(asio::io_context& io, const std::string& host, const std::string& port)
        : io(io), client(io) {
        client.connect(host, port);
    }

    std::string async_send_request(const std::string& request) {
        co_await asio::co_spawn(io, [&]() -> awaitable<void> {
            auto response = client.send_request(request);
            co_return;
        }, asio::use_awaitable);

        // 返回结果
        co_return "Response received";
    }
};

int main() {
    asio::io_context io;
    AsyncHttpClient client(io, "example.com", "80");

    auto result = client.async_send_request("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n");
    std::cout << "Received response: " << result << std::endl;

    io.run();
}