struct node
{
    node* left_;
    node* right_;
    value_t value_;
};

generator(iterate_tree_t, node*) 
{
    node* root;
    node* curr;
    std::vector<node*> node_queue;

public:
    iterate_tree_t(node* root)
        : root (root)
        , curr ()
    {}

    emit(node*)
        if (0 == root)
            return; // <--- можно писать просто return - значит конец последовательности

        curr = root;
        node_queue.clear();
        node_queue.reserve(128);
        
        for (;;)
        {
            yield(curr);

            if (curr->left_ && curr->right_)
            {
                node_queue.push_back(curr->right_);
                curr = curr->left_;
            }
            else if (curr->left_)
            {
                curr = curr->left_;
            }
            else if (curr->right_)
            {
                curr = curr->right_;
            }
            else
            {
                if (node_queue.empty())
                    break;
                curr = node_queue.back();
                node_queue.pop_back();
            }
        }
    stop_emit(); // <--- не надо передавать реальный элемент
};

int main()
{
    iterate_tree_t iter (0);
    // <--- проверка теперь вначале цикла - т.е. поддерживает пустые последовательности
    while (iter.next())
        // <--- в теле можно вызывать iter.value() несколько раз - перехода не след. элемент не будет
        std::cout << "node: " << iter.value()->value_ << " " << iter.value()->value_ << std::endl;
    std::cout << "[end]" << std::endl;
}

template<typename derived_t, typename elem_t>
class generator_base
{
protected:
    int generator_line;
    elem_t generator_value;

public:
    generator_base()
        : generator_line()
    {}

    bool next()
    {
        int generator_cur_line = generator_line;
        generator_line = 0;
        static_cast<derived_t*>(this)->generate_value(generator_cur_line);
        return 0 != generator_line;
    }

    elem_t const& value()
    {
        return generator_value;
    }
};

#define generator(NAME, T) class NAME : public generator_base<NAME, T>

#define emit(T)\
    void generate_value(int generator_cur_line)\
    { switch(generator_cur_line) { case 0:;\
/**/

#define stop_emit() }}

#define yield(V)\
        do {\
            generator_line=__LINE__;\
            generator_value = (V);\
            return;\
            case __LINE__:;\
        } while (0)\
/**/

generator(iterate_tree_rec_t, node*) 
{
    node* root;
    std::vector<iterate_tree_rec_t> iter_queue;

public:
    iterate_tree_rec_t(node* root)
        : root (root)
    {}

    emit(node*)
        if (0 == root)
            return;

        yield(root);

        {
            // <--- локальная переменная
            size_t i = 0;
            for (; i != root->children_.size(); ++i)
                iter_queue.push_back(root->children_[i]);
        }

        while (iter_queue.size())
        {
            while (iter_queue.back().next())
                yield(iter_queue.back().value());
            iter_queue.pop_back();
        }

    stop_emit();
};

::CreateFiberEx(1, 1, ...

template<typename param> 
void apply(node* n, void (*func)(node*, param&), param& p)
{
    node* l = left(n);
    node* r = right(n);
    if(l) apply(l, func, p);
    if(r) apply(r, func, p);
    func(n, param);
}   
template<typename param> 
void apply(void (*func)(node*, param&), param& p) { if(root) apply(root, func, p); }  


...
void sum(some_node* n, int& sum) { sum+=n->value; }
...
int s = 0;
some_tree.apply(sum, s);

// ...
#define generator(NAME, T, NAME_T) class NAME : public generator_base<NAME_T, T>
// ...

#include <vector>
#include <deque>
#include <math.h>
#include <time.h>
#include "../generator.h"

template <typename Primes>
generator(gen_map, unsigned, gen_map<Primes>)
{
    const unsigned p0_, p1_, lo_, hi_, bound_;
    std::vector<bool> arr_;
    unsigned i_, n_;

    static unsigned correct(unsigned n, unsigned i)
    { return n & 1 ? n : n + i; }

public:
    gen_map(unsigned p0, unsigned p1)
        : p0_(p0), p1_(p1)
        , lo_(p0 * p0), hi_(p1 * p1)
        , bound_((hi_ - lo_) / 2 - 1)
        , arr_(bound_ + 1, true)
    {
        Primes ps(3);
        for (ps.next(); ps.value() < p1_; ps.next())
        {
            const unsigned i = ps.value();
            for (unsigned j = (correct(lo_ - lo_ % i + i, i) - lo_) / 2
                ; j <= bound_
                ; j += i)
                arr_[j] = false;
        }
    }

    emit(unsigned)
    {
        for (i_ = 1, n_ = lo_ + 2; i_ <= bound_; ++i_, n_ += 2)
        {
            if (!arr_[i_])
                continue;
            yield(n_);
        }
    }
    stop_emit()
};

inline unsigned sqrt_int(unsigned x)
{ return static_cast<unsigned>(sqrt(static_cast<double>(x))); }

generator(primes, unsigned, primes)
{
    const unsigned n_, sq_n_;
    gen_map<primes> *gmap_;
    unsigned p0_, p1_, i_;
    primes *ps_;

    void dispose()
    {
        if (gmap_)
            delete gmap_;
        gmap_ = 0;
    }

public:
    primes(unsigned n = 2)
        : n_(n)
        , sq_n_(sqrt_int(n))
        , gmap_(0)
        , ps_(0)
    {
    }

    ~primes()
    {
        dispose();
        if (ps_)
            delete ps_;
    }

    emit(unsigned)
    {
        if (n_ <= 2) yield(2);
        if (n_ <= 3) yield(3);
        if (n_ <= 5) yield(5);
        if (n_ <= 7) yield(7);
        ps_ = new primes(3);
        ps_->next();
        p1_ = ps_->value();
        for (;;)
        {
            p0_ = p1_;
            ps_->next();
            p1_ = ps_->value();
            if (p1_ <= sq_n_)
                continue;
            dispose();
            gmap_ = new gen_map<primes>(p0_, p1_);
            while (gmap_->next())
                if (gmap_->value() >= n_)
                    yield(gmap_->value());
        }
    }
    stop_emit()
};

int main()
{
    primes ps(100000000);
    int sum = 0;
    long tim0 = clock();
    for (ps.next(); ps.value() <= 120000000; ps.next(), ++sum);
    printf("sum = %d, time: %g sec.\n", sum, (clock() - tim0) / 1000.0);
}

#define yield(V)\
        do {\
            this->generator_line=__LINE__;\
            this->generator_value = (V);\
            return;\
            case __LINE__:;\
        } while (0)\