What are coroutines in C++ and how do they work?

What are coroutines in C++ and how do they work?

Coroutines in C++ are a generalization of subroutines that allow you to pause and resume functions. They enable asynchronous programming by allowing functions to yield control back to the caller, making it easier to write non-blocking code.

Can you give me an example of a coroutine in C++?

Sure! Here's a simple example:

#include <iostream>
#include <coroutine>

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::exit(1); }
        auto yield_value(int value) {
            current_value = value;
            return std::suspend_always{};
        }
        void return_void() {}
    };

    promise_type *promise;
    Generator(promise_type *p) : promise(p) {}
    int next() {
        promise->current_value = 0;
        promise->initial_suspend();
        return promise->current_value;
    }
};

Generator count() {
    for (int i = 0; i < 5; ++i) {
        co_yield i;
    }
}

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

This code defines a simple generator that yields numbers from 0 to 4.

What are the benefits of using coroutines?

Coroutines simplify asynchronous programming by allowing you to write code that looks synchronous. They help manage state without complex callback structures, making the code easier to read and maintain. Additionally, they can improve performance by reducing context switching overhead.