c++协程（Coroutines）-无限的整数序列

科学的发展-只不过是读大自然写的代码

已于 2024-12-28 13:35:53 修改

阅读量1.1k

点赞数 12

分类专栏： # c++11 文章标签： c++ java 前端

于 2024-12-25 08:34:27 首次发布

本文链接：https://blog.youkuaiyun.com/xie__jin__cheng/article/details/144707948

版权

c++11 专栏收录该内容

64 篇文章

订阅专栏

1.概要

2.内容

协程（Coroutines）是C++20引入的一种特性，它使得编写异步代码变得更加简单和直观。协程允许函数在执行过程中暂停并在稍后恢复，从而实现非阻塞的异步操作。以下是对C++协程的详细介绍：

一、协程的基本概念

协程是一种计算机程序组件，用于协同完成任务的子例程。它被视为轻量级线程，拥有自己的暂停点状态。协程可以在执行过程中暂停，将当前状态保存起来，并在稍后恢复执行时恢复之前保存的状态。协程不是由操作系统内核所管理，而是完全由程序所控制，因此具有极高的执行效率。

二、协程的关键字和用法

co_await：用于挂起当前的协程，等待某个异步操作完成。
co_return：用于从当前协程返回一个结果。
co_yield：用于返回一个结果并挂起当前的协程，可以在之后恢复执行并继续产生新的结果。

三、协程的实现原理

协程的实现原理是基于状态机的。编译器将协程函数转换为一个状态机，其中包含多个状态，每个状态对应协程函数中的一个执行点。协程的执行过程就是通过状态之间的切换来实现的。当协程挂起时，它会保存当前的状态并返回到调用者；当协程恢复执行时，它会从之前保存的状态继续执行。

四、协程的Promise类型

在C++中，协程的返回类型必须是Promise类型。Promise类型是一个结构体，它定义了协程的行为，包括如何处理返回值和异常。Promise类型中必须实现以下接口：

get_return_object：用于创建并返回协程的返回对象。
initial_suspend：在协程开始执行时调用，用于决定协程是否应该在第一次执行时保持挂起。
final_suspend：在协程结束执行时调用，用于决定协程是否应该在结束时保持挂起。
return_void/return_value：用于处理协程的返回值。
yield_value：用于处理协程的yield操作。
unhandled_exception：用于处理协程中未捕获的异常。

五、协程的示例代码

以下是一个简单的C++协程示例代码，它演示了如何使用co_yield关键字生成一个无限的整数序列：

#include <coroutine>
#include <iostream>

struct Generator {
    struct promise_type {
        Generator get_return_object() {
            return Generator{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::exit(1); }
        std::suspend_always yield_value(int value) {
            current_value = value;
            return {};
        }
        int current_value;
    };

    using handle_type = std::coroutine_handle<promise_type>;
    handle_type handle;

    Generator(handle_type h) : handle(h) {}
    ~Generator() { handle.destroy(); }

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

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

Generator<int> getNext(int start = 0, int step = 1) {
    int value = start;
    for (;;) {
        co_yield value;
        value += step;
    }
}

int main() {
    auto gen = getNext();
    for (int i = 0; i <= 10; ++i) {
        gen.next();
        std::cout << gen.getValue() << " ";
    }
    std::cout << std::endl;
    return 0;
}

六、协程的优势和局限性

协程的优势在于其极高的执行效率和简洁的异步编程模型。由于协程的切换是由程序自身控制的，而不是由操作系统内核管理的，因此协程切换的开销远小于线程切换。此外，协程还可以有效地减少回调函数的复杂性，使异步代码更加易于编写和维护。

然而，协程也存在一些局限性。例如，协程无法利用多核资源，因为它本质上是一个单线程模型。此外，协程的调试和错误处理也可能比线程更加复杂。

总的来说，C++协程是一种强大的编程工具，它可以帮助开发者更高效地实现异步编程和并发处理。随着C++标准的不断发展和完善，协程的应用前景也将越来越广阔。

3.关联链接

c++模块（Modules）-优快云博客

c++20：概念（Concepts）-优快云博客

c++20:范围（Ranges）-优快云博客

c++20:协程（Coroutines）-优快云博客

c++协程（Coroutines）-无限的整数序列-优快云博客

三路比较运算符（Spaceship Operator）-优快云博客

std::format-优快云博客

c++20,位操作增强-优快云博客

c++20 空指针比较-优快云博客

4.关联知识

1.Promise类型

Promise类型是异步编程中的一种解决方案，它提供了一种优雅的方式来处理异步操作的结果。以下是关于Promise类型的详细介绍：

一、Promise的基本概念

定义：Promise对象用于表示一个异步操作的最终完成（或失败）及其结果值。它是一个容器，可以存储异步操作的结果状态和数据。
状态：Promise对象有三种状态：
- Pending（待定）：初始状态，表示异步操作尚未完成。
- Fulfilled（已兑现）：表示异步操作成功完成。
- Rejected（已拒绝）：表示异步操作失败。

二、Promise的基本用法

创建Promise对象：使用new Promise(executor)语法创建Promise对象，其中executor是一个执行器函数，它接受两个参数：resolve和reject。
处理异步操作结果：通过then()方法添加处理成功结果的回调函数，通过catch()方法添加处理失败结果的回调函数。
链式调用：Promise对象支持链式调用，可以依次添加多个then()和catch()方法，以便按顺序处理异步操作的结果。

三、Promise的高级用法

Promise.all()：用于并行执行多个异步操作，并在所有异步操作都成功时返回结果数组。如果任何一个异步操作失败，则立即进入失败回调。
Promise.allSettled()：与Promise.all()类似，但不管异步操作是成功还是失败，都会返回结果数组。每个结果对象包含状态和值（或原因）。
Promise.any()：返回第一个成功完成的Promise的结果。如果所有Promise都失败，则返回最后一个失败的结果。
Promise.race()：返回第一个改变状态的Promise的结果。无论是成功还是失败，都会立即返回结果。

四、Promise的优点

避免回调地狱：通过链式调用和async/await语法，Promise使得异步代码的编写和阅读更加直观和简单。
提高代码的可读性和可维护性：Promise将异步操作的结果处理逻辑与业务逻辑分离，使得代码结构更加清晰。
更好的错误处理：Promise提供了catch()方法来统一处理异步操作中的错误，避免了传统回调函数中错误处理的复杂性。

五、Promise的实现原理

状态管理：Promise对象内部通过维护一个状态来表示异步操作的完成情况。一旦状态改变（从Pending变为Fulfilled或Rejected），就不会再改变。
回调函数管理：Promise对象内部通过维护两个回调函数数组（成功回调和失败回调）来管理异步操作完成后的回调逻辑。当状态改变时，会依次执行相应的回调函数。
链式调用实现：then()方法返回一个新的Promise对象，以便实现链式调用。新的Promise对象的状态和结果取决于回调函数的执行结果。

总之，Promise类型是异步编程中的一种强大工具，它使得异步代码的编写和阅读更加直观和简单。通过理解Promise的基本概念、基本用法、高级用法以及实现原理，我们可以更好地利用它来处理异步操作。

2.c++20有什么新功能

C++20 是 C++ 标准的一个重要更新，它引入了许多新特性和改进，显著提升了语言的功能性和易用性。以下是一些关键的新功能：

一、模块（Modules）

功能：改变了组织源码文件的方式，旨在替换传统的头文件 #include 模型，以减少编译时间和改善依赖管理。在项目中，不再需要区分 .cpp 和 .h 文件。
示例：

// my_module.module
export module my_module;
export void greet() {
    std::cout << "Hello from the module!" << std::endl;
}

// main.cpp
import my_module;
int main() {
    greet();
    return 0;
}

二、概念（Concepts）

功能：允许在编译时精确指定模板参数需满足的条件，增强编译时错误信息和泛型编程的清晰度。
示例：

#include <concepts>

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

template<Integral T>
T abs(T x) {
    return x >= 0 ? x : -x;
}

int main() {
    static_assert(abs(42) == 42);
    static_assert(abs(-42) == 42);
    // static_assert(abs(42.0) == 42.0); // 错误，double不满足Integral概念
}

三、范围（Ranges）

功能：扩展了标准库中的算法，支持更简洁、更灵活的序列操作。Ranges 库是对标准模板库（STL）的一个重要扩展，它重新定义了容器和算法的交互方式，使代码更具可读性和表达力。
示例：

#include <range/v3/all.hpp>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5, 6};
    auto even = vec | ranges::view::filter([](int x) { return x % 2 == 0; });
    for (int val : even) {
        std::cout << val << " ";
    }
    return 0;
}

四、协程（Coroutines）

功能：正式支持协程，使得编写异步代码更为直观。协程是一种特殊的函数，允许在执行过程中暂停并在稍后恢复。
示例（简化的生成器示例）：

#include <coroutine>
#include <iostream>

struct Generator {
    struct promise_type;
    using handle_t = std::coroutine_handle<promise_type>;

    Generator(handle_t h) : coro(h) {}

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

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

private:
    handle_t coro;
};

struct Generator::promise_type {
    int current_value{0};
    Generator get_return_object() {
        return Generator{handle_t::from_promise(*this)};
    }

    std::suspend_always initial_suspend() { return {}; }

    std::suspend_always final_suspend() noexcept { return {}; }

    void return_value(int value) {
        current_value = value;
    }

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

Generator count_up_to(int limit) {
    for (int i = 1; i <= limit; ++i) {
        co_yield i;
    }
}

int main() {
    for (int val : count_up_to(5)) {
        std::cout << val << " ";
    }
    return 0;
}

五、三路比较运算符（Spaceship Operator）

功能：引入了<=>运算符，用于实现综合比较（小于、等于、大于）。
示例：

#include <compare>

struct Point {
    int x, y;
    auto operator<=>(const Point&) const = default;
};

int main() {
    Point p1{1, 2}, p2{1, 2};
    if (p1 == p2) std::cout << "Equal" << std::endl;
}

六、std::format

功能：C++20 引入的标准库函数，为字符串格式化提供了统一且强大的接口，类似于 Python 中的 str.format 或 C 的 printf 函数，但更加安全和灵活。
示例：

#include <format>
#include <iostream>

int main() {
    auto str = std::format("The answer is {}.", 42);
    std::cout << str << std::endl; // 输出: The answer is 42.
    return 0;
}

七、位操作增强

功能：C++20 对位操作进行了增强，引入了几个新函数来提高位操作的便利性和表达能力。
示例（使用 std::has_single_bit 和 std::countl_zero）：

#include <bit>
#include <iostream>

int main() {
    unsigned int num = 0b100000;
    std::cout << "Is power of 2?" << std::boolalpha << std::has_single_bit(num) << std::endl;
    std::cout << "Leading zeros: " << std::countl_zero(num) << std::endl;
}

八、空指针比较

功能：C++20 引入了新的空指针常量 nullptr 与整数类型的比较操作，明确禁止了这种比较，以防止潜在的逻辑错误。以前，比较 nullptr 和整数在某些实现下是允许的，但现在这样的比较会引发编译错误，确保了代码的清晰和安全。
示例（演示非法比较）：

void checkPointer(int* ptr) {
    // if (ptr == 0) // 在C++20中，这种比较会被认为是错误的。
    // std::cout << "ptr is null" << std::endl;
}

九、其他改进和新增特性

关键字和语法增强：引入了 co_await、co_return、co_yield 等关键字以支持协程，consteval 用于声明必须在编译时求值的常量表达式函数，constinit 用于声明必须在编译时初始化的变量，以及 inline 变量等。
constexpr 支持的扩展：C++20 扩展了 constexpr 的能力，使其可以用于更复杂的表达式和函数，包括虚函数、动态内存分配、try-catch 异常处理等。
std::span：一个轻量级的视图类型，表示一段连续内存的子集，它类似于指针和数组，但更安全、更易用。
类型安全和错误检查：通过引入概念（Concepts）和范围（Ranges），C++20 提供了更强的类型安全和更好的编译时错误检查。

总的来说，C++20 的这些新特性和改进使得 C++ 语言更加现代化、强大和易用。