C++20特性：协程与模块化编程‌

C++20 协程

C++20 引入了协程（Coroutines）作为核心语言特性，提供了一种更高效的异步编程模型。协程允许函数在特定点挂起和恢复，而无需阻塞线程。txmj99.comAAA

协程通过 co_await、co_yield 和 co_return 关键字实现。co_await 用于挂起协程直到异步操作完成，co_yield 用于生成值并挂起，co_return 用于结束协程。dynaev.comAAA

协程的实现依赖于编译器生成的代码和用户提供的承诺类型（promise type）。承诺类型定义了协程的行为，包括初始挂起、最终挂起和异常处理。sysws8.comAAA

#include <coroutine>
#include <iostream>

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

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

    explicit Generator(promise_type* p)
        : coro(handle::from_promise(*p)) {}
    ~Generator() { if (coro) coro.destroy(); }

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

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

int main() {
    auto gen = range(1, 5);
    for (int i = 0; i < 4; ++i) {
        std::cout << gen.next() << " ";
    }
}

C++20 模块化编程

C++20 引入了模块（Modules）作为新的代码组织方式，旨在替代传统的头文件包含机制。模块提供了更快的编译速度、更好的封装性和更清晰的依赖管理。yanweishi.netAAA

模块通过 export 关键字导出接口，通过 import 关键字导入其他模块。模块接口单元（.ixx 或 .cppm）包含导出的声明，模块实现单元包含具体实现。szsz16888.comAAA

模块的主要优势包括：zhangyilaw.comAAA

• 减少编译时间：避免重复解析头文件。kfhyjx.comAAA
• 更好的封装：仅导出必要的接口。zhsrlzy.comAAA
• 无宏污染：模块内的宏不会影响导入者。msdhn.comAAA

// math.ixx
export module math;

export int add(int a, int b) {
    return a + b;
}

// main.cpp
import math;
import <iostream>;

int main() {
    std::cout << add(3, 4) << "\n";
    return 0;
}

协程与模块化的结合应用

协程和模块化可以结合使用，构建高效的异步库。例如，将协程相关的功能封装为模块，提供清晰的接口和高效的实现。pyelm.comAAA

// async.ixx
export module async;

import <coroutine>;
import <future>;

export template<typename T>
struct Task {
    struct promise_type {
        T value;
        std::promise<T> promise;
        auto get_return_object() { return Task{*this}; }
        auto initial_suspend() { return std::suspend_never{}; }
        auto final_suspend() noexcept { return std::suspend_always{}; }
        void return_value(T v) {
            value = v;
            promise.set_value(v);
        }
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> coro;
    explicit Task(promise_type& p) : coro(std::coroutine_handle<promise_type>::from_promise(p)) {}
    ~Task() { if (coro) coro.destroy(); }

    std::future<T> get_future() { return coro.promise().promise.get_future(); }
};

export Task<int> async_add(int a, int b) {
    co_return a + b;
}

// main.cpp
import async;
import <iostream>;
import <future>;

int main() {
    auto task = async_add(3, 4);
    auto result = task.get_future().get();
    std::cout << result << "\n";
    return 0;
}

ynaxdt.comAAA tzyonghong.comAAA concisebloc.comAAA cdayxkj.comAAA www.telidz.comAAA www.spulszone.comAAA