Is There a Standard Algorithm to Iterate Over a Range? - c++

Question

I need to call a lambda with every int in a range. Is there a standard algorithm that does this?
Ideally something equivalent:
for(auto i = 13; i < 42; ++i)[](int i){/*do something*/}(i);

Answer 1

There's nothing built-in, no.
You can do it yourself with a hand-crafted iterator and std::for_each, or use Boost's counting iterators to help you along:
#include <boost/iterator/counting_iterator.hpp>
#include <algorithm>
#include <iostream>
int main()
{
std::for_each(
boost::counting_iterator<int>(13),
boost::counting_iterator<int>(42),
[](int i){ std::cout << i << ' '; }
);
}
Output:
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
(live demo)

Answer 2

I don't know of anything in the standard library that can produce a range of numbers on demand like you're asking for. But this can be done a couple of different ways using Boost.
Use Boost.Range to generate an integer range and use it with the range version of for_each
boost::for_each(boost::irange(13, 42), [](int i){ std::cout << i << ' '; });
Use boost::counting_iterator from Boost.Iterator and pass those to std::for_each
std::for_each(boost::make_counting_iterator(13),
boost::make_counting_iterator(42),
[](int i){ std::cout << i << ' '; });
Live demo

Answer 3

As the other answers have mentioned if Boost is an option there is a better way to do this. If not, the best way is in the original question:
for(auto i = 13; i < 42; ++i)[](int i){/*do something*/}(i);
However, the future is bright, chris has mentioned proposal N4128 which is suggesting incorporating ranges into the standard alongside iterators.
Now the draft is still in an early state, so there's a lot of clarification that is needed before how this will be used is nailed down. But one of the concepts is that all the STL algorithms would be overloaded to take views which is a thin wrapper providing access to the contained elements, but also an intelligent end position.
Although a more complex example, chosen to showcase the power of view, the author's example in Motivation and Scope uses iota, which is exactly what we want:
int total = accumulate(view::iota(1) |
view::transform([](int x){return x*x;}) |
view::take(10), 0);
For our purposes we'd need to use generate_n in a for_each algorithm:
for_each(view::generate_n(28,[]{static int i = 13; return i++;}),[](int i){/*do something*/});
This would cause generate_n to be called 28 times (13 + 28 = 41), the created view would provide iteration over these numbers, feeding them into our original lambda in the for_each.
chris has suggested that instead of generate_n a modification of iota might do the trick: iota(13, 41) It is key to note that whatever is used must have an end condition, because view lazily calls the generator, until no more items are requested. So this for_each(view::iota(10), [](int i){/*do something*/}); defines an infinite loop.