public void Consumer()
{
foreach(int i in Integers())
{
Console.WriteLine(i.ToString());
}
}
public IEnumerable<int> Integers()
{
yield return 1;
yield return 2;
yield return 4;
yield return 8;
yield return 16;
yield return 16777216;
}
有没有办法通过模板技巧（或其他）在 c++ 中获得相同的语法？
【问题讨论】：
yield 在幕后所做的事情。
标签： c++
Coroutines are in the C++20 draft 并使用co_yield 而不是yield。
另见：What are coroutines in C++20?
第一个链接中有一些示例用法：（第二个可能是您要查找的）
使用
co_await运算符暂停执行直到恢复task<> tcp_echo_server() { char data[1024]; for (;;) { size_t n = co_await socket.async_read_some(buffer(data)); co_await async_write(socket, buffer(data, n)); } }使用关键字
co_yield暂停执行返回值generator<int> iota(int n = 0) { while(true) co_yield n++; }使用关键字
co_return完成执行返回值lazy<int> f() { co_return 7; }
【讨论】：
这是 ASM “自己动手”的版本：http://www.flipcode.com/archives/Yield_in_C.shtml
#include <stdio.h
#include <conio.h
#include <iostream.h
//
// marks a location in the program for resume
// does not return control, exits function from inside macro
//
// yield( x, ret )
// x : the 'name' of the yield, cannot be ambiguous in the
// function namespace
// ret : the return value for when yield() exits the function;
// must match function return type (leave blank for no return type)
#define yield(x,ret) \
{ \
/* store the resume location */ \
__asm { \
mov _myStaticMkr,offset label_##x \
} \
\
/* return the supplied value */ \
return ret; \
} \
/* our offset in the function */ \
label_##x:
//
// resumes function from the stored offset, or
// continues without notice if there's not one
// stored
//
// resume()
// <void
#define resume() \
/* our stored offset */ \
static _myStaticMkr=0; \
\
/* test for no offset */ \
if( _myStaticMkr ) \
{ \
/* resume from offset */ \
__asm \
{ \
jmp _myStaticMkr \
} \
}
// example demonstrating a function with an int return type
// using the yield() and resume() macros
//
// myFunc()
// <void
int myFunc()
{
resume();
cout << "1\n";
yield(1,1);
cout << "2\n";
yield(2,1);
cout << "3\n";
yield(3,1);
cout << "4\n";
return 0;
}
// main function
//
// main()
// <void
void main( void )
{
cout << "Yield in C++\n";
cout << "Chris Pergrossi\n\n";
myFunc();
do
{
cout << "main()\n";
cout.flush();
} while( myFunc() );
cout.flush();
getch();
}
/*
// example demonstrating a function with no return type
// using the yield() and resume() macros
//
// myFunc()
// <void
void myFunc()
{
resume();
cout << "1\n";
yield(1);
cout << "2\n";
yield(2);
cout << "3\n";
yield(3);
cout << "4\n";
return;
}
// main function
//
// main()
// <void
void main( void )
{
cout << "Yield in C++\n";
cout << "Chris Pergrossi\n\n";
myFunc();
for( int k = 0; k < 4; k ++ )
{
cout << "main()\n";
cout.flush();
myFunc();
}
cout.flush();
getch();
}
*/
【讨论】：
您始终可以手动编写代码。说实话，yield 对我来说真的像是糖衣（以及协同程序）。
什么是协程，真的吗？一些状态捆绑在一起：
在 C++ 中称为InputIterator，可以任意胖。
所以，语法确实不会那么漂亮，但这应该可以，只需使用标准库：
static std::array<int, 6> const Array = {{1, 2, 4, 8, 16, 16777216}};
class Integers: public std::iterator<std::input_iterator_tag,
int, ptrdiff_t, int const*, int>
{
public:
Integers(): _index(0) {}
operator bool() const { return _index < Array.size(); }
Integers& operator++() { assert(*this); ++_index; return *this; }
Integers operator++(int) { Integers tmp = *this; ++*this; return tmp; }
int operator*() const { assert(*this); return Array[_index]; }
int const* operator->() const { assert(*this); return &Array[_index]; }
private:
size_t _index;
}; // class Integers
显然，由于 您 决定存储什么状态，因此您决定是否全部预先计算，或者是否部分（或全部）延迟计算，并可能缓存，并且可能多-线程，并且......你明白了:)
【讨论】：
yield，我的看法是，与其将 C# 语法“移植”到 C++ 中，不如反思它在做什么并找到 C++ 中的惯用语。协程只不过是InputIterator。
for 循环是什么，但while 循环上的糖衣是什么？什么是switch，而是if 的级联？语法糖不一定是坏事，因为没有它我们仍然会将十六进制操作码直接打入内存。这只是你在哪里画线的问题。您似乎将它画在只有一个循环语句加一个分支语句的语言和一种包括yield 的语言之间。其他包括yield。我，我用过它，看到了它的意义，但不管有没有它都可以。
next_permutation 的实现几乎证明了我的观点，即它要复杂几倍（毕竟这只是一个例子而不是唯一的用例）。而且我从来没有听说过将参数重新注入到挂起的函数中——而且维基百科上列出的任何一种语言似乎都没有这种功能。 “糖衣”的全部意义不是隐藏编译器可以完成但对程序员来说相当复杂的东西吗？在我看来，c++ 与 c 相反，抽象了很多。
在 C++14 中，您可以这样模仿 yield：
auto&& function = []() {
int i = 0;
return [=]() mutable {
int arr[] = {1,2,4,8,16,16777216};
if ( i < 6 )
return arr[i++];
return 0;
};
}();
http://ideone.com/SQZ1qZ 上提供了一个实时示例
【讨论】：
yield的目的不就是防止一系列对象（本例为int[]）被立即放入内存吗？
针对 C++17 提出了类似的建议，并且已经在 Visual C++ 2015 中进行了实验性实现。这里有一个很好的概述 talk，来自该提案的主要作者之一 Gor Nishanov。
【讨论】：
如果您写static unsigned int checkpoint = 0;，则将所有变量设为static、switch (checkpoint)，将每个case: goto 设置为某个标签，在每个return 上方设置检查点为唯一值，在下方定义标签，并在函数结束将检查点设置为零，所有静态变量设置为其默认值，最后return 函数的结束值。如果你做了所有这些，那么函数就变成了enumerable和iterative。您在每条return 行的上方和下方添加的两行使return 命令的行为类似于yield return。 goto 允许您从中断的地方继续和恢复，static 整数变量，如检查点，帮助您记住停止的位置、从哪里继续/恢复以及去哪里。您可以使用 switch case 语句测试它的值。将其他所有变量设为static，就是将它们的值保存到下一次调用中，所以在下一次调用中，它们的值不会被重置！
这里举例：
#define PowerEnd INT_MIN
int Power(int number, int exponent)
{
static unsigned int checkpoint = 0;
static int result = 1, i = 0;
switch (checkpoint)
{
case 1: goto _1;
}
for (i = 0; i < exponent; i++)
{
result *= number;
checkpoint = 1;
return result;
_1:;
}
checkpoint = 0;
result = 1;
i = 0;
return PowerEnd;
}
void main()
{
while (true)
{
int result = Power(2, 8);
if (result == PowerEnd)
break;
cout << result << endl;
}
//to print only the first 4 results (if there are at least 4 results) then
for (int i = 0; i < 4; i++)
{
int result = Power(2, 8);
if (result == PowerEnd)
break;
cout << result << endl;
}
}
上述程序产生以下输出：
2 4 8 16 32 64 128 256 2 4 8 16
【讨论】：
如果您需要的只是类似 foreach 的东西，那么 C++ 中可以使用以下语法：
#define GENERATOR(name) \
struct name \
{ \
template<typename F> \
void operator()(F yield) \
/**/
#define _ };
template<typename Gen>
struct Adaptor
{
Gen f;
template<typename C>
void operator*(C cont)
{
f(cont);
}
};
template<typename Gen>
Adaptor<Gen> make_adaptor(Gen gen)
{
return {gen};
}
#define FOREACH(arg, gen) make_adaptor(gen) * [&](arg)
#include <iostream>
using namespace std;
GENERATOR(integers)
{
yield(1);
yield(2);
yield(4);
yield(8);
yield(16777216);
}_
int main()
{
FOREACH(int i, integers())
{
cout << i << endl;
};
}
如果你需要一点协程“力量”，那么你可以试试stackless coroutines。
或者，如果您需要充分的能力 - 然后使用堆栈式协程。有Boost.Coroutine 库，为不同平台实现堆栈协程。
【讨论】：
#include <setjmp.h>
class superclass
{
public:
jmp_buf jbuf;
public:
virtual int enumerate(void) { return -1; }
};
class subclass: public superclass
{
public:
int enumerate()
{
static int i;
static bool b = false;
if(b)
longjmp(jbuf, 1);
for(b = true, i = 0; i < 5; (i)++)
{
printf("\ndoing stuff: i = %d\n", i);
if(setjmp(jbuf) != 1)
return i;
}
return -1;
}
};
要使用代码...
int iret;
subclass *sc;
sc = new subclass();
while((iret = sc->enumerate()) != -1)
{
printf("\nsc->enumerate() returned: %d\n", iret);
}
刚刚开始工作；现在看起来很简单，虽然我有一些错误的开始:)
【讨论】：
尝试在c++中实现yield coroutine
【讨论】：
当然，您总是可以编写自己的迭代器并从它们返回您想要的任何东西，但您为什么要这样做呢？在给定的示例中，为什么不简单地将您的值放入像 vector 这样的容器中并对其进行迭代？
【讨论】：
std::vector 需要通过重新分配/复制例程来增加其大小（除非事先知道，通常情况下您不需要知道迭代器块）。
看看 boost::Coroutine。它做你想做的事。 http://www.crystalclearsoftware.com/soc/coroutine/index.html#coroutine.intro
教程中的示例
http://www.crystalclearsoftware.com/soc/coroutine/coroutine/tutorial.html
int range_generator(generator_type::self& self, int min, int max)
{
while(min < max)
self.yield(min++);
self.exit();
}
【讨论】：
self.exit() 是如何合法替代退货声明的。 （我怀疑这是对异常的可怕滥用或longjmp，但我不确定我想知道！）