五分钟看懂 C++20 协程：从"回调地狱"到"天堂之路"

// 同步方式的代码示例 - 这会导致程序卡住！😱
string processOrder() {
    // 服务员傻等食材准备好 (卡住 5 秒) 🕐
    auto ingredients = getIngredients();  // 阻塞等待
    
    // 服务员继续傻等厨师炒菜 (卡住 10 秒) 🕙
    auto dish = cook(ingredients);        // 阻塞等待
    
    // 服务员还要傻等装盘 (卡住 3 秒) 🕒
    auto platedDish = plate(dish);        // 阻塞等待
    
    // 这期间服务员什么都干不了！
    // - 不能接待新客人 😢
    // - 不能收拾餐桌 😫
    // - 不能处理其他订单 😩
    
    return platedDish;
}

// 这是一个典型的回调地狱示例
void processUserClick() {
    // 第一层回调: 从数据库获取数据
    // 问题1: 这里的错误处理只能处理数据库错误,无法处理后续步骤的错误
    fetchFromDatabase([](DbResult dbData) {           
        // 第二层回调: 将数据上传到服务器
        // 问题2: 这时如果想要访问外层的变量很困难,作用域被分割了
        uploadToServer(dbData, [](ServerResponse resp) {   
            // 第三层回调: 处理服务器响应
            // 问题3: 如果这里想要提前返回,必须层层往外传递信号
            processResponse(resp, [](FinalResult fr) {         
                // 第四层回调: 更新UI
                // 问题4: 代码缩进已经严重影响可读性
                updateUI(fr, [](UIState state) {                   
                    if (state.hasError) {
                        // 问题5: 错误处理变得极其困难
                        // - 无法统一处理错误
                        // - 资源清理容易遗漏
                        // - 异常传播路径不清晰
                    }
                });
            });
        });
    });
}

async Task doSomethingAsync() {
    auto result = co_await startOperation();        // 优雅得像一首诗！ ✨
    auto nextResult = co_await processResult(result);    // 代码如丝般顺滑~ 🎭
    auto finalResult = co_await finalStep(nextResult);   // 完美！就是这样！ 🌟
}

template<typename T>
struct Task {
    struct promise_type {  // 这个神秘的 promise_type 就像是协程的"灵魂" 👻
        T result;         // 存储协程的"宝藏" 💎
        
        // 创建协程时的"开光仪式" 🕯️
        auto get_return_object() { return Task{handle_type::from_promise(*this)}; }
        
        // 协程的"起床气" 😴
        auto initial_suspend() { return suspend_never{}; }
        
        // 协程的"睡前祷告" 🌙
        auto final_suspend() noexcept { return suspend_always{}; }
        
        // 收获胜利果实的时刻 🏆
        void return_value(T value) { result = value; }
        
        // 当一切都出错时的"紧急按钮" 🚨
        void unhandled_exception() { throw; }
    };
    // 还有一大堆让人眼花缭乱的实现细节,像迷宫一样复杂 🌀
};

Task<int> fibonacci(int n) {
    if (n <= 2) co_return 1;  // 优雅地返回～ 🎀
    auto a = co_await fibonacci(n - 1);  // 等等我哦～ 🌸
    auto b = co_await fibonacci(n - 2);  // 马上就好～ 🌺
    co_return a + b;  // 完美收工！ 🎯
}

co_await  // 等待型英雄，擅长"时间暂停" ⏸️
co_yield  // 生产型英雄，负责"物资运输" 📦
co_return // 终结型英雄，专门"画上句点" 🎯

Task<string> fetchUserData() {
    // 管家：主人，我去帮您取数据，您先喝杯茶吧 ☕️
    auto response = co_await http.get("/api/user");  
    // 管家：主人，数据已经准备好啦！🎉
    co_return response.body();
}

Generator<int> range(int start, int end) {
    for(int i = start; i < end; ++i) {
        co_yield i;  // 小蜜蜂：嗡嗡～这是第i份蜂蜜，我去采下一份啦～ 🍯
    }
}

Task<double> calculateAverage(vector<int> numbers) {
    if(numbers.empty()) {
        co_return 0.0;  // 空数组？那就直接说再见啦～ 👋
    }
    double sum = 0;
    for(auto n : numbers) {
        sum += n;  // 一个一个加起来... 🧮
    }
    co_return sum / numbers.size();  // 完美收工！🎀
}

// ❌ 这些都不能是协程：
consteval auto func1() { co_return 42; }     // 不能用于 consteval 函数
constexpr auto func2() { co_return 42; }     // 不能用于 constexpr 函数
auto main() { co_return 0; }                 // main 函数不能是协程
struct S { S() { co_return; } };             // 构造函数不能是协程
struct S { ~S() { co_return; } };            // 析构函数不能是协程

// ✅ 这些可以是协程：
Task<int> func3() { co_return 42; }          // 普通函数可以
auto lambda = []() -> Task<int> {            // lambda 表达式可以
    co_return 42;
};

Task<User> getUserInfo() {
    // 就像是在跟老朋友聊天一样自然~ 🫂
    auto token = co_await auth.login();         // 先敲门说声"您好"~ 🚪
    auto profile = co_await user.getProfile(token);    // 聊聊近况如何啊~ 📝
    auto settings = co_await user.getSettings(token);  // 顺便问问有什么新变化~ ⚙️
    
    co_return User{profile, settings};  // 愉快地道别，期待下次相见！👋
}

Generator<int> fibonacci() {
    int a = 0, b = 1;
    while(true) {
        co_yield a;        // 像变魔术一样，变出一个斐波那契数 🎭
        auto temp = a + b; // 施展数学魔法，计算下一个数 ✨
        a = b;            // 像跳舞一样，优雅地交换数字 💃
        b = temp;         // 为下一次表演做准备~ 🎪
    }
}

// 让我们欣赏这场数学表演吧！
void useFibonacci() {
    auto fib = fibonacci();  // 请出我们的魔术师 🧙♂️
    for(int i = 0; i < 10; ++i) {
        cout << fib() << " ";  // 一个接一个，数字像魔法一样冒出来 ✨
    }                          // 瞧：0 1 1 2 3 5 8 13 21 34 🎉
}

AsyncStream<DataPacket> processDataStream() {
    while(true) {
        auto data = co_await streamSource.readNext();
        if(data.isEmpty()) break;
        
        // 处理数据
        auto processed = co_await processData(data);
        co_yield processed;
    }
}

// 像个优雅的睡美人 👸
auto initial_suspend() { return std::suspend_always{}; }

// 像个永不停歇的陀螺 🔄 (可能会消耗更多魔法值哦)
auto initial_suspend() { return std::suspend_never{}; }

struct Task {
    struct promise_type {
        // 施展内存分配魔法 🪄
        void* operator new(size_t size) {
            return customAllocator.allocate(size); // 变出一块完美的内存空间 ✨
        }
        
        // 优雅地清理魔法现场 🧹
        void operator delete(void* ptr, size_t size) {
            customAllocator.deallocate(ptr, size); // 让内存重归自然 🍃
        }
    };
};