"co_yield"是否可以在恢复协程时从调用方返回值?

Question

C++20 引入了协程，可用于创建生成器和其他类似的东西：

generator<int> counter(int max) {
for(int i = 0; i < max; i++) {
co_yield i;
}
}

有没有办法创建一个协程，以便调用方可以提供在协程恢复后由co_yield返回的响应？我们称之为channel而不是生成器。

这是我希望能够做的事情的一个例子：

channel<int, int> accumulator(int initial) {
while(true) {
// Can channel be written so co_yield provides a response?
int response = co_yield initial;
initial += response;
}
}

在这里，每当调用方恢复协程时，它都会提供一个值，一旦协程恢复，该值就会从co_yield返回，如下所示：

std::vector<int> accumulate(std::vector<int> values) {
channel<int, int> acc = accumulator(0);
std::vector<int> summed_values;
for(int v : values) {
// Get whatever value was yielded by the accumulator
int sum = acc.recieve();
// Do something with the value
summed_values.push_back(sum);
// Resume the accumulator, returning this value from co_yield:
acc.send(v); 
}
return summed_values;
}

根据评论进行编辑

任何人都可以提供一些关于如何做到这一点的指导或示例吗？协程对我来说仍然很新。我有一个channel类的基本实现，但我不确定应该从yield_value返回什么才能实现这一点。

我在评论中标记了(A)和(B)的两个位置。

template <class Out, class In>
struct channel {
struct promise_type {
Out current_value;
auto yield_value(Out value) {
current_value = value;
// (A) What do I return here?
}
channel get_return_object() {
return {std::coroutine_handle<promise_type>::from_promise(*this)};
}
// We run up until the first value is ready
auto initial_suspend() noexcept { return std::suspend_never(); }
auto final_suspend() noexcept { return std::suspend_always(); }
void unhandled_exception() noexcept { std::terminate(); }
};

Out receive() {
return handle.promise().current_value;
}
void send(In response) {
// (B) What do I do here?
}
// Constructors, destructor and move assignment operator omitted for brevity
private:
std::coroutine_handle<promise_type> handle = nullptr;
};

Answer 1

密钥是await_resume，在等待者(yield_value的结果(上调用它来获取co_yield的结果。

您还需要将响应存储在某个位置。正如 Raymond Chen 在评论中建议的那样，您可以将值放入promise_type的新数据成员中。

所以变化是：

1. 将数据成员添加到promise_type。

   In response;
   

2. 定义自定义等待程序以返回该数据成员。

   struct awaiter : std::suspend_always {
   friend promise_type;
   constexpr In await_resume() const { return m_p->response; }
   private:
   constexpr awaiter(promise_type* p) : m_p(p) {}
   promise_type* m_p;
   };
   

3. 在(A)中，返回自定义的等待者。

   return awaiter(this);
   

4. 在(B)中，设置数据成员，然后恢复协程。

   handle.promise().response = response;
   handle.resume();