Coroutines (C++20)

Introduced in C++20, Coroutines are functions that can suspend execution and resume later. Unlike standard functions, their state is allocated on the heap rather than the stack, allowing them to yield values lazily.

Stackless Design

C++20 coroutines are stackless. When a coroutine is suspended, its execution state (variables, parameters, and instruction pointer) is saved in a heap-allocated activation frame. This allows other tasks to run on the thread without allocating a thread stack for each coroutine.

Code Walkthrough

Implementing a lazy integer generator using C++20 coroutines.

#include <iostream>
#include <coroutine>
struct Generator {
    struct promise_type {
        int current_value;
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 unhandled_exception() { std::terminate(); }
        void return_void() {}
std::suspend_always yield_value(int value) {
            current_value = value;
            return {};
        }
    };
std::coroutine_handle<promise_type> coro;
Generator(std::coroutine_handle<promise_type> h) : coro(h) {}
    ~Generator() { if (coro) coro.destroy(); }
bool next() {
        coro.resume();
        return !coro.done();
    }
int value() { return coro.promise().current_value; }
};
Generator range(int start, int end) {
    for (int i = start; i <= end; ++i) {
        co_yield i; // Suspends coroutine and returns value
    }
}
int main() {
    auto gen = range(1, 3);
    while (gen.next()) {
        std::cout << "Generated: " << gen.value() << std::endl;
    }
    return 0;
}

Interview-Relevant Information