Implement a lazy generator as forward_iterator in C ++

Question

MyGenerator represents a (possibly) finite sequence of integers that is expensive to compute. Therefore, I do not want to generate them all in advance and put them in a container.

struct MyGenerator{
  bool HasNext();
  int Next();
}

To print them all:

MyGenerator generator;
while (generator.HasNext()) {
  std::cout << generator.Next() << std::endl;
}

How to implement a similar generator following the forward_iterator protocol?

boost :: function_input_iterator is approaching, but I don't know the number of elements up.

Answer 1

-, boost::function_input_iterator, , , , , , , , , . , Boost , : -)

, - ():

template <typename Generator>
struct generator_iterator : iterator<forward_iterator_tag, int> {
    generator_iterator(const Generator &gen, end = false) : count(0), gen(gen), last_val(0), is_end(end) {
        if (!end) advance();
    }
    void advance() {
        if (gen.HasNext()) {
            lastval = gen.Next();
        } else {
            is_end = True;
        }
        count += 1;
    }
    int operator *() {
        return lastval;
    }
    generator_iterator &operator++() {
        advance();
        return *this;
    }
    generator_iterator operator++(int) {
        generator_iterator result = *this;
        advance();
        return result;
    }
    bool operator==(const generator_iterator &rhs) {
        return (is_end && rhs.is_end) || (count == rhs.count);
    }
    bool operator!=(const generator_iterator &rhs) {
        return !(*this == rhs);
   }

    size_t count;
    Generator gen;
    int lastval;
    bool is_end; 
};

• , , size_t, 64 . , , : uint64_t . std::iterator, , , size_t, difference_type.
• Generator ( , ), forward_iterator, . input_iterator, Generator .
• MyGenerator, , , , , , advance().