Как лениво генерировать готовую последовательность элементов и перебирать ее

вы должны использовать идиому C++: прямой итератор. Это позволяет использовать синтаксический сахар C++ и поддерживать стандартную библиотеку. Вот минимальный пример:

template<int tstart, int tstop, int tstep = 1>
class Range {
public:
    class iterator {
        int start;
        int stop;
        int step;
        int current;
    public:
        iterator(int start, int stop, int step = 0, int current = tstart) : start(start), stop(stop), step(step == 0 ? (start < stop ? 1 : -1) : step), current(current) {}
        iterator& operator++() {current += step; return *this;}
        iterator operator++(int) {iterator retval = *this; ++(*this); return retval;}
        bool operator==(iterator other) const {return std::tie(current, step, stop) == std::tie(other.current, other.step, other.stop);}
        bool operator!=(iterator other) const {return !(*this == other);}
        long operator*() {return current;}
        // iterator traits
        using difference_type = int;
        using value_type = int;
        using pointer = const int*;
        using reference = const int&;
        using iterator_category = std::forward_iterator_tag;
    };
    iterator begin() {return iterator{tstart, tstop, tstep};}
    iterator end() {return iterator{tstart, tstop, tstep, tstop};}
};

его можно использовать с путем C++98:

using range = Range<0, 10, 2>;
auto r = range{};
for (range::iterator it = r.begin() ; it != r.end() ; ++it) {
    std::cout << *it << '\n';
}

или с новым циклом диапазона:

for (auto n : Range<0, 10, 2>{}) {
    std::cout << n << '\n';
}

в cunjunction с stl:

std::copy(std::begin(r), std::end(r), std::back_inserter(v));

демо:http://coliru.stacked-crooked.com/a/35ad4ce16428e65d

диапазон, основанный на цикле for, - это итератор, реализующий begin (), end () и operator++.

Итак, генератор должен реализовать их.

template<typename T>
struct generator {
    T first;
    T last;

    struct iterator {
        using iterator_category = std::input_iterator_tag;
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = T *;
        using reference = T &;
        T value;

        iterator(T &value) : value(value) {}

        iterator &operator++() {
            ++value;
            return *this;
        }
        iterator operator++(int) = delete;

        bool operator==(const iterator &rhs) { return value == rhs.value; }
        bool operator!=(const iterator &rhs) { return !(*this == rhs); }
        const reference operator *() { return value; }
        const pointer operator->() const { return std::addressof(value); }
    };

    iterator begin() { return iterator(first); }
    iterator end() { return iterator(last); }
};

затем добавьте функцию, которая создает экземпляр генератора, и все готово

template<typename T>
generator<T> range(T start, T end) {
    return generator<T>{ start, end };
}

for (auto i : range(0, 10))
{
}

вариант использования, который вы описываете (конкатенация диапазонов и т. д.) может оправдать зависимость от библиотеки, поэтому вот решение, основанное на диапазон-v3, на пути в C++20. Вы можете легко перебрать целые значения, здесь от 0 до 10 с шагом 2,

#include <range/v3/all.hpp>

using namespace ranges;

for (auto i : view::ints(0, 11) | view::stride(2))
   std::cout << i << "\n";

или реализовать аналогичный цикл со значениями с плавающей запятой (обратите внимание, что [from, to] здесь является замкнутым диапазоном, а третий аргумент обозначает количество шагов)

for (auto f : view::linear_distribute(1.25f, 2.5f, 10))
   std::cout << f << "\n";

и когда он доходит до конкатенации, библиотека начинает светиться:

const std::vector world{32, 119, 111, 114, 108, 100};

for (auto i : view::concat("hello", world))
   std::cout << char(i);

std::cout << "\n";

обратите внимание, что вышеуказанные фрагменты компилируются с -std=c++17. Библиотека является только заголовком.