C++でyieldを使ったプログラミングの7つの方法

#include <iostream>
#include <coroutine>

void simpleYieldExample() {
    for (int i = 0; i < 5; ++i) {
        std::cout << "Before yield: " << i << std::endl;
        yield;
        std::cout << "After yield: " << i << std::endl;
    }
}

int main() {
    simpleYieldExample();
    return 0;
}

#include <iostream>
#include <coroutine>

void conditionalYieldExample() {
    for (int i = 0; i < 10; ++i) {
        if (i % 2 == 0) {  // 偶数の場合にyieldを呼び出す
            yield;
        }
        std::cout << "Loop iteration: " << i << std::endl;
    }
}

int main() {
    conditionalYieldExample();
    return 0;
}

#include <iostream>
#include <coroutine>

struct MyCoroutine {
    struct promise_type {
        MyCoroutine get_return_object() { return {}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};

MyCoroutine exampleCoroutine() {
    std::cout << "Coroutine started" << std::endl;
    co_yield;
    std::cout << "Coroutine resumed" << std::endl;
}

int main() {
    auto coro = exampleCoroutine();
    // ここでcoro.resume()を呼び出してコルーチンを再開する
    return 0;
}

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

void threadFunction() {
    for (int i = 0; i < 5; ++i) {
        std::this_thread::yield(); // 他のスレッドに実行を譲る
        std::cout << "Thread iteration: " << i << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 少し待機
    }
}

int main() {
    std::thread t(threadFunction);
    t.join();
    return 0;
}

#include <iostream>
#include <vector>
#include <coroutine>

struct DataStream {
    std::vector<int> data;

    bool hasData() const {
        return !data.empty();
    }

    int readData() {
        if (!data.empty()) {
            int value = data.front();
            data.erase(data.begin());
            return value;
        }
        return -1; // データがない場合
    }
};

MyCoroutine processData(DataStream& stream

) {
    while (stream.hasData()) {
        int value = stream.readData();
        co_yield value; // データを処理
    }
}

int main() {
    DataStream stream{{1, 2, 3, 4, 5}};
    auto process = processData(stream);
    // ここでプロセスを進行させるコードを書く
    return 0;
}

#include <iostream>
#include <coroutine>
#include <vector>
#include <thread>

struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };

    // タスク処理関数
    static void processTasks(std::vector<Task>& tasks) {
        for (auto& task : tasks) {
            // ここでタスクの処理を非同期に行う
        }
    }
};

Task asyncTask() {
    std::cout << "Task started" << std::endl;
    co_yield;
    std::cout << "Task resumed" << std::endl;
}

int main() {
    std::vector<Task> tasks;
    tasks.push_back(asyncTask());
    Task::processTasks(tasks);
    return 0;
}

#include <iostream>
#include <coroutine>

template<typename T>
struct Generator {
    struct promise_type;
    using handle_type = std::coroutine_handle<promise_type>;

    struct promise_type {
        T value;
        std::suspend_always yield_value(T v) { value = v; return {}; }
        Generator get_return_object() { return Generator(handle_type::from_promise(*this)); }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };

    handle_type coro;

    Generator(handle_type h) : coro(h) {}
    ~Generator() { if (coro) coro.destroy(); }

    bool next() {
        if (coro) {
            coro.resume();
            return !coro.done();
        }
        return false;
    }

    T value() const { return coro.promise().value; }
};

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

int main() {
    auto gen = generateNumbers();
    while (gen.next()) {
        std::cout << "Generated number: " << gen.value() << std::endl;
    }
    return 0;
}