Introduction to C++ coroutines

25 Sep 2023

To use coroutines in C++, you need to use the co_await keyword, which tells the compiler to suspend the coroutine until the awaited operation is complete. Coroutines are typically used with asynchronous operations such as I/O, networking, or when waiting for a task to complete.

Let’s take a look at a simple example using coroutines in C++:

#include <iostream>
#include <experimental/coroutine>

using namespace std::experimental;

template<typename T>
struct async_generator {
    struct promise_type;
    using handle_type = coroutine_handle<promise_type>;
    
    struct promise_type {
        T value;
        std::experimental::suspend_always yield_value(T value) {
            this->value = value;
            return {};
        }
        
        std::experimental::suspend_always initial_suspend() {
            return {};
        }
        
        std::experimental::suspend_always final_suspend() noexcept {
            return {};
        }
        
        async_generator get_return_object() {
            return {handle_type::from_promise(*this)};
        }
        
        void return_void() {}
        void unhandled_exception() {}
    };
    
    struct iterator {
        handle_type coro;
        bool done;
        
        void operator++() {
            coro.resume();
            done = coro.done();
        }
        
        bool operator!=(const iterator& other) const {
            return done != other.done;
        }
        
        T operator*() const {
            return coro.promise().value;
        }
    };
    
    iterator begin() {
        if (coro) {
            coro.resume();
        }
        return {*coro, coro.done()};
    }
    
    iterator end() {
        return {coro, true};
    }
    
    explicit async_generator(handle_type handle)
        : coro(handle) {}
    
    ~async_generator() {
        if (coro) {
            coro.destroy();
        }
    }
    
private:
    handle_type coro;
};

In the above code, we define a struct async_generator that implements a generator using coroutines. The generator can be used to yield values asynchronously. We use the suspend_always and suspend_never classes from the std::experimental namespace to handle suspending and resuming the generator.

To use the generator, you can define a coroutine function and use the co_await keyword to yield values from within the generator. Here’s an example:

async_generator<int> generate_integers() {
    co_yield 1;
    co_yield 2;
    co_yield 3;
}

void consume_generator() {
    auto generator = generate_integers();
    for (auto value : generator) {
        std::cout << value << std::endl;
    }
}

In the generate_integers function, we use the co_yield keyword to yield values 1, 2, and 3 from the generator. In the consume_generator function, we create an instance of the generator and iterate through its values using a range-based for loop.

C++ coroutines provide a clean and readable way to write asynchronous code, making it easier to manage complex control flows. By using coroutines, you can improve the performance and efficiency of your C++ programs.

#C++ #Coroutines