blocks|key|1206429|text|我最近在coroutines+in+C上找到了一篇很好的文章，其中描述了一种这样做的方法。这肯定不是为胆小鬼准备的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1206430|entityMap|0|LINK|mutability|MUTABLE|url|http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html^0|4|F|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I found a good article recently on <a href="http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html" rel="noreferrer">coroutines in C</a>, which describes one method of doing this. It's certainly not for the faint of heart.

blocks|key|1206494|text|基本的方法是不去做它。在Python+(和C#)中，“yield”方法在调用之间存储本地状态，而在C/C%2B%2B和大多数其他语言中，堆栈上存储的本地状态不会在调用之间保留，这是一个基本的实现差异。因此，在C语言中，你必须将两次调用之间的状态显式地存储在某个变量中--要么是全局变量，要么是序列生成器的函数参数。因此，要么：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1206495|int+multiples_of_2()+{
+++static+int+i+=+0;
+++i+%2B=+2;
+++return+i;
}|code-block|syntax|javascript|1206496|或|1206497|int+multiples_of_2(int+i)+{
+++i+%2B=+2;
+++return+i;
}|1206498|这取决于是否有一个或多个全局序列。|1206499|我很快就考虑了longjmp和GCC计算goto和其他非标准的东西，我不能说我会推荐他们中的任何一个！在C中，用C的方式来做。|1206500|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The basic approach is to not do it. In Python (and C#) the 'yield' method stores local state between calls, whereas in C/C++ and most other languages the local state stored on the stack is not preserved between calls and this is a fundemental implementation difference. So in C you'd have to store the state between calls in some variable explicitly - either a global variable or a function parameter to your sequence generator. So either:

<pre><code>int multiples_of_2() {
 static int i = 0;
 i += 2;
 return i;
}
</code></pre>

or

<pre><code>int multiples_of_2(int i) {
 i += 2;
 return i;
}
</code></pre>

depending upon if there's one global sequence or many.

I've quickly considered longjmp and GCC computed gotos and other non-standard things, and I can't say I'd recommend any of them for this! In C, do it the C way.

blocks|key|1206557|text|int+multiples_of_2()+{
++++static+int+i+=+0;
++++i+%2B=+2;
++++return+i;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1206558|静态int的行为类似于全局变量，但仅在multiples_of_2()的内容中可见。|unstyled|1206559|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>int multiples_of_2() {
 static int i = 0;
 i += 2;
 return i;
}
</code></pre>

The static int i behaves like a global variable but is visible only within the contect of multiples_of_2().

blocks|key|1206584|text|可以将参数作为指针传递，以允许函数在不使用返回值的情况下对其进行修改：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1206585|void+multiples_of_2(int+*i)
{
++++*i+%2B=+2;
}|code-block|syntax|javascript|1206586|并将其称为：|1206587|int+i+=+0;
multiples_of_2(&i);|1206588|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can pass the argument as a pointer to allow the function to modify it without using the return value:

<pre><code>void multiples_of_2(int *i)
{
 *i += 2;
}
</code></pre>

And call it:

<pre><code>int i = 0;
multiples_of_2(&amp;i);
</code></pre>

blocks|key|1421710|text|您可以尝试将其封装在struct中|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1421711|typedef+struct+s_generator+{
++++int+current;
++++int+(*func)(int);
}+generator;

int+next(generator*+gen)+{
++++int+result+=+gen->current;
++++gen->current+=+(gen->func)(gen->current);
++++return+result;
}|code-block|syntax|javascript|1421712|然后，您可以使用以下命令定义您的倍数：|1421713|int+next_multiple(int+current)+{+return+2+%2B+current;+}
generator+multiples_of_2+=+{0,+next_multiple};|1421714|通过调用以下方法获得下一个倍数|1421715|next(&multiples_of_2);|1421716|entityMap^0|A|6|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|T|$]]

You could try to encapsulate this in a <code>struct</code>:

<pre><code>typedef struct s_generator {
 int current;
 int (*func)(int);
} generator;

int next(generator* gen) {
 int result = gen-&gt;current;
 gen-&gt;current = (gen-&gt;func)(gen-&gt;current);
 return result;
}
</code></pre>

Then you define you multiples with:

<pre><code>int next_multiple(int current) { return 2 + current; }
generator multiples_of_2 = {0, next_multiple};
</code></pre>

You get the next multiple by calling

<pre><code>next(&amp;multiples_of_2);
</code></pre>

blocks|key|1421763|text|如前所述，像python这样的语言负责在生成器的连续调用之间存储堆栈的状态。因为C语言没有这种机制，所以你必须自己去做。正如Greg所指出的，这种“通用”的方式不适合胆小鬼。传统的C语言方式是自己定义和维护状态，并将其传入和传出您的方法。所以：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1421764|struct+multiples_of_two_state+{
+++++++int+i;
+++++++/*+all+the+state+you+need+should+go+in+here+*/
};

void+multiples_of_two_init(struct+multiples_of_two_state+*s)+{
++++s->i+=+0;
}

int+multiples_of_two_next(struct+multiples_of_two_state+*s)+{
++++s->i+%2B=+2;
++++return+s->i;
}

/*+Usage+*/
struct+multiples_of_two_state+s;
int+result;
multiples_of_two_init(&s);
for+(int+i=0;+i<INFINITY;+i%2B%2B)+{
++++result+=+multiples_of_two_next(&s);
++++printf("next+is+%25d",+result);
}|code-block|syntax|javascript|1421765|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

As Will mentioned, languages like python do the job of storing the state of the stack between successive calls of the generator. Since C does not have this mechanism, you'll have to do it yourself. The "generic" way of doing this is not for the faint-hearted, as Greg pointed out. The traditional C way of doing this would be for you to define and maintain the state yourself and pass it in and out of your method. So:

<pre><code>struct multiples_of_two_state {
 int i;
 /* all the state you need should go in here */
};

void multiples_of_two_init(struct multiples_of_two_state *s) {
 s-&gt;i = 0;
}

int multiples_of_two_next(struct multiples_of_two_state *s) {
 s-&gt;i += 2;
 return s-&gt;i;
}

/* Usage */
struct multiples_of_two_state s;
int result;
multiples_of_two_init(&amp;s);
for (int i=0; i&lt;INFINITY; i++) {
 result = multiples_of_two_next(&amp;s);
 printf("next is %d", result);
}
</code></pre>

blocks|key|1206739|text|为了解决hamming的问题，我已经实现了我自己的lazy+eval。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1206740|下面是我的代码，供感兴趣的人参考：|1206741|#include+<stdio.h>
#include+<stdlib.h>

//+Hamming+problem+in+C.

typedef+struct+gen+{
++int+tracker;
++int+(*next)(struct+gen+*g);
}+generator;

int+twos_gen(struct+gen+*g)+{
++g->tracker+=+g->tracker+%2B+2;
++return+g->tracker;
}

generator*+twos_stream()+{
++generator+*g+=+malloc(sizeof(generator));
++g->next+=+twos_gen;
++g->tracker+=+0;
++return+g;
}

int+threes_gen(struct+gen+*g)+{
++g->tracker+=+g->tracker+%2B+3;
++return+g->tracker;
}

generator*+threes_stream()+{
++generator+*g+=+malloc(sizeof(generator));
++g->next+=+threes_gen;
++g->tracker+=+0;
++return+g;
}

int+fives_gen(struct+gen+*g)+{
++g->tracker+=+g->tracker+%2B+5;
++return+g->tracker;
}

generator*+fives_stream()+{
++generator+*g+=+malloc(sizeof(generator));
++g->next+=+fives_gen;
++g->tracker+=+0;
++return+g;
}

int+smallest(int+a,+int+b,+int+c)+{
++if+(a+<+b)+{
++++if+(c+<+a)+return+c;
++++return+a;
++}
++else+{
++++if+(c+<+b)+return+c;
++++return+b;
++}
}

int+hamming_gen(struct+gen+*g)+{
++generator*+twos+=+twos_stream();
++generator*+threes+=+threes_stream();
++generator*+fives+=+fives_stream();

++int+c2+=+twos->next(twos);
++int+c3+=+threes->next(threes);
++int+c5+=+fives->next(fives);

++while+(c2+<=+g->tracker)+c2+=+twos->next(twos);
++while+(c3+<=+g->tracker)+c3+=+threes->next(threes);
++while+(c5+<=+g->tracker)+c5+=+fives->next(fives);

++g->tracker+=+smallest(c2,c3,c5);
++return+g->tracker;
}

generator*+hammings_stream()+{
++generator+*g+=+malloc(sizeof(generator));
++g->next+=+hamming_gen;
++g->tracker+=+0;
++return+g;
}

int+main()+{
++generator*+hammings+=+hammings_stream();
++int+i+=+0;
++while+(i<10)+{
++++printf("Hamming+No:+%25d\n",hammings->next(hammings));
++++i%2B%2B;
++}
}|code-block|syntax|javascript|1206742|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I have implemented my own lazy eval, with respects to solving the hamming's problem.

Heres my code for anyone whos interested:

<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

// Hamming problem in C.

typedef struct gen {
 int tracker;
 int (*next)(struct gen *g);
} generator;

int twos_gen(struct gen *g) {
 g-&gt;tracker = g-&gt;tracker + 2;
 return g-&gt;tracker;
}

generator* twos_stream() {
 generator *g = malloc(sizeof(generator));
 g-&gt;next = twos_gen;
 g-&gt;tracker = 0;
 return g;
}

int threes_gen(struct gen *g) {
 g-&gt;tracker = g-&gt;tracker + 3;
 return g-&gt;tracker;
}

generator* threes_stream() {
 generator *g = malloc(sizeof(generator));
 g-&gt;next = threes_gen;
 g-&gt;tracker = 0;
 return g;
}

int fives_gen(struct gen *g) {
 g-&gt;tracker = g-&gt;tracker + 5;
 return g-&gt;tracker;
}

generator* fives_stream() {
 generator *g = malloc(sizeof(generator));
 g-&gt;next = fives_gen;
 g-&gt;tracker = 0;
 return g;
}

int smallest(int a, int b, int c) {
 if (a &lt; b) {
 if (c &lt; a) return c;
 return a;
 }
 else {
 if (c &lt; b) return c;
 return b;
 }
}

int hamming_gen(struct gen *g) {
 generator* twos = twos_stream();
 generator* threes = threes_stream();
 generator* fives = fives_stream();

 int c2 = twos-&gt;next(twos);
 int c3 = threes-&gt;next(threes);
 int c5 = fives-&gt;next(fives);

 while (c2 &lt;= g-&gt;tracker) c2 = twos-&gt;next(twos);
 while (c3 &lt;= g-&gt;tracker) c3 = threes-&gt;next(threes);
 while (c5 &lt;= g-&gt;tracker) c5 = fives-&gt;next(fives);

 g-&gt;tracker = smallest(c2,c3,c5);
 return g-&gt;tracker;
}

generator* hammings_stream() {
 generator *g = malloc(sizeof(generator));
 g-&gt;next = hamming_gen;
 g-&gt;tracker = 0;
 return g;
}

int main() {
 generator* hammings = hammings_stream();
 int i = 0;
 while (i&lt;10) {
 printf("Hamming No: %d\n",hammings-&gt;next(hammings));
 i++;
 }
}
</code></pre>

Take for example,

The follow python code:

<pre><code>def multiples_of_2():
 i = 0
 while True:
 i = i + 2
 yield i
</code></pre>

How do we translate this into C code?

Edit: I am looking to translate this python code into a similar generator in C, with next() function. What I am not looking for is how to create a function in C to output multiples of 2. Multiples of 2 is merely an example to illustrate the problem of lazy eval generators in C.

How would one implement Lazy Evaluation in C?

Python

举个例子，以下是python代码：def multiples_of_2():  i = 0  while True:    i = i + 2    yield i我们怎么把它翻译成C代码呢？编辑:我希望将这段python代码翻译成一个类似的C生成器，使用next()函数。我不是在寻找如何在C中创建一个函数来输出2的倍...

问如何在C中实现惰性求值？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C中实现惰性求值？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C中实现惰性求值？
EN