C# C中的产量#

这在c中是否有任何等效功能？

否。在Windows上，您可以使用光纤来实现类似的效果。

光纤？哦，这个：

使用光纤
的本机C++收益率迭代器

---

虽然C在对集合进行枚举方面没有与收益率相同的概念，但它确实能够创建协同路由和光纤

以下是一些可能感兴趣的维基百科文章：

---

否。但是，使用可以在C中实现类似的效果，但这非常棘手。

编译器将Yield作为实现状态机的自定义类来实现。虽然您不能很容易地获得语法（除非您使用前面指定的fiber方法），但是您可以非常简单地自己复制结果，尽管这相当繁琐。下面是（我将在C语言中显示，你必须根据你使用的类型在C++中做适当的事情）：

假设以下代码：

public IEnumerable<T> GetOddStrings(
  IEnumerable<IEnumerable<string>> stringCollections)
{
    foreach(var stringCollection in stringCollections)
      foreach(var str in stringCollection)
      {
        if(str.Length %2 != 0) yield return str;
        if(str.Length == 42) yield break;  // 42 is BAD! Stop immediately
      }
}

public IEnumerable GetOddStrings(
IEnumerable字符串集合）
{
foreach（stringCollections中的变量stringCollection）
foreach（stringCollection中的var str）
{
如果（str.Length%2！=0）产生返回str；
如果（str.Length==42）屈服断裂；//42不好！立即停止
}
}

1） 将所有foreach方法展开为显式枚举器调用：

public IEnumerable<T> GetOddStrings(
  IEnumerable<IEnumerable<string>> stringCollections)
{
  var firstEnumerator = stringCollection.GetEnumerator();
  while(firstEnumerator.MoveNext())
  {
    var secondEnumerator = firstEnumerator.Current.GetEnumerator();
    while(secondEnumerator.MoveNext())
    { 
      var str= secondEnumerator.Current;
      if(str.Length %2 != 0) yield return str;
      if(str.Length == 42) yield break;
    }
  }
}

public IEnumerable GetOddStrings(
IEnumerable字符串集合）
{
var firstEnumerator=stringCollection.GetEnumerator（）；
while（firstEnumerator.MoveNext（））
{
var secondEnumerator=firstEnumerator.Current.GetEnumerator（）；
while（secondEnumerator.MoveNext（））
{ 
var str=secondEnumerator.Current；
如果（str.Length%2！=0）产生返回str；
如果（str.Length==42）屈服断裂；
}
}
}

2） 将所有局部变量移到方法的顶部：

public IEnumerable<T> GetOddStrings(
  IEnumerable<IEnumerable<string>> stringCollections)
{
  IEnumerator<IEnumerable<string>> firstEnumerator;
  IEnumerator<string> secondEnumerator;
  string str;

  firstEnumerator = stringCollections.GetEnumerator();
  while(firstEnumerator.MoveNext())
  {
    secondEnumerator = firstEnumerator.Current.GetEnumerator();
    while(secondEnumerator.MoveNext())
    { 
      str= secondEnumerator.Current;
      if(str.Length %2 != 0) yield return str;
      if(str.Length == 42) yield break;
    }
  }
}

public IEnumerable GetOddStrings(
IEnumerable字符串集合）
{
IEnumerator firstEnumerator；
IEnumerator第二枚举器；
字符串str；
firstEnumerator=stringCollections.GetEnumerator（）；
while（firstEnumerator.MoveNext（））
{
secondEnumerator=firstEnumerator.Current.GetEnumerator（）；
while（secondEnumerator.MoveNext（））
{ 
str=第二个枚举数。当前；
如果（str.Length%2！=0）产生返回str；
如果（str.Length==42）屈服断裂；
}
}
}

3） 移动到带有嵌套switch语句的循环构造。
a） 改变状态，并为每个收益率回报继续循环。 b） 如果条件满足，则反转 c） 每个出口条件的屈服断裂（下面我们反转if）

public IEnumerable GetOddStrings(
IEnumerable字符串集合）
{
IEnumerator firstEnumerator；
IEnumerator第二枚举器；
字符串str；
int state=0；
while（true）
{
开关（状态）
{
案例0：
firstEnumerator=stringCollections.GetEnumerator（）；
//这可能是“收益率突破”，但我想告诉你
//可以在else中使用重要代码拆分ifs
如果（！firstEnumerator.MoveNext（））
{ 
状态=1；
继续；
}
secondEnumerator=firstEnumerator.Current；
如果（！secondEnumerator.MoveNext）继续；
状态=2；
如果（str.Length%2！=0）产生返回str；
继续；
案例1：
屈服断裂；
案例2：
如果（str.Length==42）屈服断裂；
状态=0；
继续；
}
}
}

4） 移动到类中并从方法返回该类： a） 收益率中断变为“返回错误” b） 收益率返回变为“this.Current=？；返回true；”

public IEnumerable GetOddStrings(
IEnumerable字符串集合）
{
返回新的OddStringEnumerable（stringCollections）；
}
私有类OddStringEnumerable:IEnumerable
{
IEnumerable字符串集合；
IEnumerator firstEnumerator；
IEnumerator第二枚举器；
字符串str；
int状态；
公共OddStringEnumerable（IEnumerable stringCollections）
{
this.stringCollections=stringCollections；
}
公共字符串当前{get；private set；}
公共图书馆
{
while（true）
{
开关（状态）
{
案例0：
firstEnumerator=this.stringCollections.GetEnumerator（）；
如果（！this.firstEnumerator.MoveNext（））
{ 
该状态=1；
继续；
}
this.secondEnumerator=this.firstEnumerator.Current；
如果（！secondEnumerator.MoveNext）继续；
该状态=2；
如果（str.Length%2！=0）
{
这个。电流=str；
返回true；
}
继续；
案例1：
返回false；
案例2：
if（str.Length==42）返回false；
该状态=0；
继续；
}
}
}
}

5） 适当地优化。

使用一些预处理器黑客技术，但实现了相当自然的（相对于C中的任何其他工具）

收益率

而您可以用Python编写以下内容：

"""This is actually a built-in function.
def range(start, stop, step):
    i = start
    while i < stop:
        yield i
        i = i + step
"""

if __name__ == '__main__':
    import sys
    start = int(sys.argv[1]) if len(sys.argv) > 2 else 0
    stop = int(sys.argv[2]) if len(sys.argv) > 2 else int(sys.argv[1])
    step = int(sys.argv[3]) if len(sys.argv) > 3 else 1
    for i in range(start, stop, step):
        print i,
    print

def hamming():
    yield 1

    i2 = (2*x for x in hamming())
    i3 = (3*x for x in hamming())
    i5 = (5*x for x in hamming())

    m2, m3, m5 = i2.next(), i3.next(), i5.next()

    while True:
        if m2 < m3:
            if m2 < m5:
                yield m2
                m2 = i2.next()
            else:
                if m2 > m5: yield m5
                m5 = i5.next()
        elif m2 == m3: m3 = i3.next()
        elif m3 < m5:
            yield m3
            m3 = i3.next()
        else:
            if m3 > m5: yield m5
            m5 = i5.next()

if __name__ == '__main__':
    import sys
    it = hamming()
    for i in range(str(sys.argv[1]) if len(sys.argv) > 1 else 25):
        print it.next(),
    print

$cc range.c
美元/年出10美元
0 1 2 3 4 5 6 7 8 9 
对于更复杂且需要可重入性的内容，Python中的：

"""This is actually a built-in function.
def range(start, stop, step):
    i = start
    while i < stop:
        yield i
        i = i + step
"""

if __name__ == '__main__':
    import sys
    start = int(sys.argv[1]) if len(sys.argv) > 2 else 0
    stop = int(sys.argv[2]) if len(sys.argv) > 2 else int(sys.argv[1])
    step = int(sys.argv[3]) if len(sys.argv) > 3 else 1
    for i in range(start, stop, step):
        print i,
    print

def hamming():
    yield 1

    i2 = (2*x for x in hamming())
    i3 = (3*x for x in hamming())
    i5 = (5*x for x in hamming())

    m2, m3, m5 = i2.next(), i3.next(), i5.next()

    while True:
        if m2 < m3:
            if m2 < m5:
                yield m2
                m2 = i2.next()
            else:
                if m2 > m5: yield m5
                m5 = i5.next()
        elif m2 == m3: m3 = i3.next()
        elif m3 < m5:
            yield m3
            m3 = i3.next()
        else:
            if m3 > m5: yield m5
            m5 = i5.next()

if __name__ == '__main__':
    import sys
    it = hamming()
    for i in range(str(sys.argv[1]) if len(sys.argv) > 1 else 25):
        print it.next(),
    print

def hamming（）：
收益率1
i2=（2*x代表哈明（）中的x）
i3=（3*x代表哈明（）中的x）
i5=（5*x代表哈明（）中的x）
m2，m3，m5=i2.next（），i3.next（），i5.next（）
尽管如此：
如果m2m5：产量m5
m5=i5.next（）
elif m2==m3:m3=i3.next（）
elif m3m5：产量m5
m5=i5.next（）
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
导入系统
it=hamming（）
对于范围内的i（str（sys.argv[1]），如果len（sys.argv）>1，则为25）：
打印它。下一步（），
打印

和C：

#include <coroutine.h>
#include <stdio.h>

int hamming(ccrContParam) {
    ccrBeginContext;
    ccrContext z[3];
    int m2, m3, m5;
    ccrEndContext(state);

    ccrBegin(state);
    state->z[0] = state->z[1] = state->z[2] = 0;
    ccrReturn(1);

#define m2_next (2*hamming(&state->z[0]))
#define m3_next (3*hamming(&state->z[1]))
#define m5_next (5*hamming(&state->z[2]))

    state->m2 = m2_next, state->m3 = m3_next, state->m5 = m5_next;

    while (1) {
        if (state->m2 < state->m3) {
            if (state->m2 < state->m5) {
                ccrReturn(state->m2);
                state->m2 = m2_next;
            } else {
                if (state->m2 > state->m5) ccrReturn(state->m5);
                state->m5 = m5_next;
            }
        } else if (state->m2 == state->m3) state->m3 = m3_next;
        else if (state->m3 < state->m5) {
            ccrReturn(state->m3);
            state->m3 = m3_next;
        } else {
            if (state->m3 > state->m5) ccrReturn(state->m5);
            state->m5 = m5_next;
        }
    }
    ccrFinish(-1);
}

int main(int argc, char **argv) {
    int count = argc > 1 ? atoi(argv[1]) : 25, i;
    ccrContext z = 0;

    for (i = 0; i < count; i++)
        printf("%d ", hamming(&z));
    printf("\n");
}

#包括
#包括
int-hamming（ccrContParam）{
ccrBeginContext；
def hamming():
    yield 1

    i2 = (2*x for x in hamming())
    i3 = (3*x for x in hamming())
    i5 = (5*x for x in hamming())

    m2, m3, m5 = i2.next(), i3.next(), i5.next()

    while True:
        if m2 < m3:
            if m2 < m5:
                yield m2
                m2 = i2.next()
            else:
                if m2 > m5: yield m5
                m5 = i5.next()
        elif m2 == m3: m3 = i3.next()
        elif m3 < m5:
            yield m3
            m3 = i3.next()
        else:
            if m3 > m5: yield m5
            m5 = i5.next()

if __name__ == '__main__':
    import sys
    it = hamming()
    for i in range(str(sys.argv[1]) if len(sys.argv) > 1 else 25):
        print it.next(),
    print

#include <coroutine.h>
#include <stdio.h>

int hamming(ccrContParam) {
    ccrBeginContext;
    ccrContext z[3];
    int m2, m3, m5;
    ccrEndContext(state);

    ccrBegin(state);
    state->z[0] = state->z[1] = state->z[2] = 0;
    ccrReturn(1);

#define m2_next (2*hamming(&state->z[0]))
#define m3_next (3*hamming(&state->z[1]))
#define m5_next (5*hamming(&state->z[2]))

    state->m2 = m2_next, state->m3 = m3_next, state->m5 = m5_next;

    while (1) {
        if (state->m2 < state->m3) {
            if (state->m2 < state->m5) {
                ccrReturn(state->m2);
                state->m2 = m2_next;
            } else {
                if (state->m2 > state->m5) ccrReturn(state->m5);
                state->m5 = m5_next;
            }
        } else if (state->m2 == state->m3) state->m3 = m3_next;
        else if (state->m3 < state->m5) {
            ccrReturn(state->m3);
            state->m3 = m3_next;
        } else {
            if (state->m3 > state->m5) ccrReturn(state->m5);
            state->m5 = m5_next;
        }
    }
    ccrFinish(-1);
}

int main(int argc, char **argv) {
    int count = argc > 1 ? atoi(argv[1]) : 25, i;
    ccrContext z = 0;

    for (i = 0; i < count; i++)
        printf("%d ", hamming(&z));
    printf("\n");
}

$ cc hamming.c
$ ./a.out
1 2 3 4 5 6 8 9 10 12 15 16 18 20 24 25 27 30 32 36 40 45 48 50 54