Generators in C++

As we know iterators in C++ is a good but not perfect abstraction. Concept of foreach() (D, Python, Ruby, etc.) appears as more generic solution. At least foreach() does not require artificial iterator::end() to be defined for the collection.

Abstraction foreach() can be imagined as some function/object that is returning next value of collection/sequence each time it is getting invoked. Such functions are known as generators.

Here is my version of generator() for the C++. It is based on the bright idea of Simon Tatham – “coroutines in C“.

First of all sample, here is a declaration of our generator function in C++:

#include "generator.h"

   int i;
   emit(int) // will emit int values. Start of body of the generator.
      for (i = 10; i > 0; i--)
         yield(i); // a.k.a. yield in Python - return next number in [1..10], reversed.
   stop(0); // stop, end of sequence. End of body of the generator.

Having declared such generator we can use it as:

int main(int argc, char* argv[])
  descent gen;
    printf("next number is %d\n", gen());
  while (gen);
  return 0;

That is pretty simple and should be intuitively clear, no?

Here is full source of the generator.h file:

// generator/continuation for C++
// author: Andrew Fedoniouk @
// idea borrowed from: "coroutines in C" Simon Tatham, 

#ifndef __generator_h_
#define __generator_h_

struct _generator
  int _line;
  _generator():_line(-1) {}
  operator bool() const { return _line != 0; }

#define generator(NAME) struct NAME : public _generator

#define emit(T)     T operator()() { \
                     if(_line < 0) { _line=0;}\
                     switch(_line) { case 0:;

#define stop(V)     } _line = 0; return (V); }

#define yield(V)     \
        do {\
            return (V); case __LINE__:;\
        } while (0)

#endif // __generator_h_


5 thoughts on “Generators in C++”

  1. I do not think that it may boost development. Take into account, plase, that this approach forces a developer to know how it’s implemented. Needless to say that it uses MACROs!!! The idea is great, somehow

  2. Yes, in principle it could be just scope block:

    #define yield(V) {\
       _line=__LINE__; \
       _rv = (V); return true; case __LINE__: _line=__LINE__;\

    Simon initially used do/while(0) so I just left it “as is”.

    But some form of ‘{‘ ‘}’ brackets is definitely needed there to
    handle properly things like if(condition) $yield(something);

  3. Here is what I’ve ended up with:

    struct _generator
        int _line;
        _generator() { rewind(); }
        void rewind() { _line = 0; }
      #define $generator(NAME) struct NAME : public tool::_generator
      #define $emit(T)       bool operator()(T& _rv) { switch(_line) { case 0:;
      #define $emit2(T1,T2)  bool operator()(T1& _rv1, T2& _rv2) { switch(_line) { case 0:;
      #define $yield(V)      { _line=__LINE__; _rv = (V); return true; case __LINE__: _line=__LINE__; }
      #define $yield2(V1,V2) { _line=__LINE__; _rv1 = (V1); _rv2 = (V2); return true; case __LINE__: _line=__LINE__; }
      #define $stop  } _line = 0; return false; }

    It also has $yield2 when you need to emit two values.

Comments are closed.