C++20 Feature : Coroutine : when to use

C++20 coroutines are perfect for situations where you want your program to handle tasks that take time—like waiting for data from a server—without freezing everything else. Imagine you’re cooking dinner and waiting for water to boil. Instead of just standing there doing nothing, you could prep the next dish while you wait. Coroutines let your program do something similar. For instance, if you’re fetching data from the internet or handling user input, you can use coroutines to pause the task while waiting for a response and then resume right where you left off when the data is ready. This makes your code cleaner and easier to read, like telling a smooth story rather than jumping all over the place.

Here’s a simple example using coroutines to simulate downloading data:

#include <iostream>
#include <coroutine>
#include <thread>
#include <chrono>

class DataFetcher {
public:
    struct promise_type {
        DataFetcher get_return_object() {
            return DataFetcher{};
        }
        std::suspend_always yield_value(int value) {
            return {};
        }
        std::suspend_never return_void() {
            return {};
        }
        void unhandled_exception() {
            std::exit(1);
        }
    };

    // Coroutine to fetch data
    static auto fetchData() {
        std::cout << "Fetching data...\n";
        std::this_thread::sleep_for(std::chrono::seconds(2)); // Simulate waiting for data
        co_yield 42; // Return the "fetched" data
        std::cout << "Data fetched!\n";
    }
};

int main() {
    auto fetcher = DataFetcher::fetchData();

    // Simulate doing something else while waiting for data
    std::cout << "Doing other work...\n";
    std::this_thread::sleep_for(std::chrono::seconds(1));

    // Resume the coroutine to get the fetched data
    std::cout << "Received data: " << *fetcher << "\n"; // Outputs 42
    return 0;
}

Explanation:

• In this example, fetchData is a coroutine that simulates fetching data. It pauses for 2 seconds to mimic waiting for a response, and then it yields the value 42.
• While the coroutine is “waiting,” you can still do other tasks, like printing “Doing other work…,” making your program feel responsive.
• When the data is ready, the coroutine resumes and you can access the fetched data.

This way, coroutines allow your program to remain active and responsive, making your coding experience smoother and more enjoyable!