如何在C++；？ 我想知道如何在C++中实现一个生成器，比如Python？ Python可以使用关键字“yield”这样做。 但是如何在C++中完成呢？

，你不能做，真的，但你可以伪造它。这里，你也可以在C++中使用。

多次调用一个协同程序，得到不同的答案意味着你保持某种状态。保持状态的方法是使用对象。使它们看起来像函数调用的方法是运算符重载。在C++中，我们有“迭代器”。一个显式地请求一个interator，显式地增加它并取消引用它

如果您希望将它们与标准库函数一起使用，则它们应该主要派生自

std:：forward\u迭代器

，并实现许多it函数

模拟集合上生成器的另一种方式是允许函数作为成员函数的参数，该成员函数向该函数提供（生成）它的所有值：

struct MyCollection {
    int values[30];

    template< typename F >  
    void generate( F& yield_function ) const {
       int* end = values+30; // make this better in your own code :)
       for( auto i: values ) yield_function( *i );
    }
};

// usage:
c.generate([](int i){ std::cout << i << std::endl; });

// or pre-C++11:
struct MyFunction { 
    void operator() (int i)const { printf( "%d\n", i); }
};
MyCollection c;
c.generate( MyFunction() );

struct MyCollection{
int值[30]；
模板
无效生成（F和屈服函数）常数{
int*end=values+30；//在您自己的代码中做得更好：）
对于（自动i：值）屈服函数（*i）；
}
};
//用法：
c、 generate（[]（inti）{std:：cout详细说明迭代器实现：这是一个示例。它可以用作循环变量，也可以用于std算法

#include <iterator>

template< typename T, typename TDiff = T >
struct TGenerator : public std::iterator<std::forward_iterator_tag,T,TDiff> {
  T from,to;
  T value;
  TDiff step;
  bool issentinel;

  TGenerator( T from, T to, TDiff step, bool sentinel = false )
    : from(from),to(to),step(step),issentinel(sentinel), value(from)
  {}

  void operator++(){ value += step; }

  const T& operator*()const { return value; }

  bool operator!=( const TGenerator& other ) const {
    return value<to;
  }

  TGenerator sentinel()const { return TGenerator(0,0,0,true); }

};


#include <algorithm>
#include <iostream>

int main()
{
  TGenerator<int> i(0,10,3);
  std::copy( i, i.sentinel(), std::ostream_iterator<int>( std::cout, " " ) );

    return 0;
}

#包括
模板
struct TGenerator:public std:：iterator{
T从，到；
T值；
TDiff步骤；
布尔·伊森蒂内尔；
T发生器（T-from，T-to，TDiff-step，bool-sentinel=false）
：from（from）、to（to）、step（step）、issentinel（sentinel）、value（from）
{}
void运算符++（）{value+=step；}
常量T&运算符*（）常量{返回值；}
布尔运算符！=（常量TGGenerator和其他）常量{
返回值您可以使用boost.context（很抱歉，还没有关于boost发行版，您必须从中获取它）

典型的示例代码如下所示：

#include <iostream>
#include <boost/context.hpp>

using namespace std;

struct Parameters {
  int par1;
  float par2;
};

boost::context c1;
boost::context c2;

void F(void* parameters) {
  Parameters& pars = *(Parameters*)parameters;
  cout << pars.par1 << endl;
  c2.jump_to(c1);
  cout << pars.par2 << endl;
};

int main() {
  c1 = boost::context::current();
  Parameters p;
  p.par1 = 8;
  c2 = boost::context::create_context( F , c1 , p );
  c1.jump_to(c2);
  p.par2 = 1.3;
  c1.jump_to(c2);
}

#包括
#包括
使用名称空间std；
结构参数{
int par1；
浮动par2；
};
boost：：上下文c1；
boost：：上下文c2；
void F（void*参数）{
参数和PAR=*（参数*）参数；
这……先生们……是纯粹的黑魔法：


<>我试过了，甚至递归地工作。从那以后我一直在使用它。生成器，几乎是C++中的第一流公民。甚至没有任何性能开销。

我向作者致以最深切的敬意
+1这正是我要说的，尽管“假装”和“实施”并没有什么区别我猜想C++中可能需要一个函子的成员变量中的协同程序状态，并调用它，在适当的情况下使用不同的实例，而不是使用全局函数，并调用一个命名函数AANKIN。C可以用额外的参数在C中做类似的事情，但不太可能要。这不是黑魔法……无论如何，这是非常不符合C++11的。很快，我们将能够添加一个与C++20协同程序的答案。