Simple integer range for C++11 range-based for loops

Question

I'm really tired of having to type

for (int iSomething = rangeBegin; iSomething < rangeEnd; ++iSomething)
{
   ...
}

whenever I want to iterate over an integer range (most IDEs help with the typing, but still it looks so verbose, naming the integer 3 times!)

I wanted something like this:

for (int iSomething : LoopRange(rangeBegin, rangeEnd))
{
   ...
}

Or if rangeBegin is 0 (the majority of the cases) then a simple

for (int iSomething : LoopRange(rangeEnd))
{
   ...
}

My very simple implementation:

class LoopRangeIterator
{
public:
    LoopRangeIterator(int value_)
        : value(value_){}

    bool operator!=(LoopRangeIterator const& other) const
    {
        return value != other.value;
    }

    int const& operator*() const
    {
        return value;
    }

    LoopRangeIterator& operator++()
    {
        ++value;
        return *this;
    }

private:
    int value;
};

class LoopRange
{
public:
    LoopRange(int from_, int to_)
        : from(from_), to(to_){}

    LoopRange(int to_)
        : from(0), to(to_){}

    LoopRangeIterator begin() const
    {
        return LoopRangeIterator(from);
    }

    LoopRangeIterator end() const
    {
        return LoopRangeIterator(to);
    }

private:
    int const from;
    int const to;
};

I named it LoopRange to make it clear that it's for loops and it isn't some general integer range class that you would use for intersecting or building union etc.

Of course this class could be generalized in many ways, but I think if you need more complex functionality (e.g. custom step sizes, double values), then you are doing something special and you are better off writing the explicit for loop.

What do you think about it? If I use such a thing throughout my project, would it confuse and disturb/distract people too much compared to just using the classic and verbose for(...; ...; ...) style?

Answer 1

Why write it yourself if you can use Boost.Range's irange. You can even adapt this to set the starting index to 0 and get std::iota type behavior (called iota_n here).

#include <boost/range/irange.hpp>
#include <iostream>

template<class Integer>
decltype(auto) iota_n(Integer last)
{
    return boost::irange(0, last);    
}

template<class Integer, class StepSize>
decltype(auto) iota_n(Integer last, StepSize step_size)
{
    return boost::irange(0, last, step_size);    
}

int main()
{
    for (auto x : iota_n(5)) // 01234
        std::cout << x;
}

Live Example, using Clang 3.4 return-type-deduction in C++1y mode (also supported by gcc 4.9, and other compilers soon (use trailing -> decltype(/*statement inside function*/) return types for C++11 compilers)

Answer 2

You can make the class template with trivial changes (add template<typename T> and change int by T in your classes), then make a construction function that deduces integer types:

template<typename T>
LoopRange<T> range(T from, T to)
{
    static_assert(std::is_integral<T>::value,
                  "range only accepts integral values");

    return { from, to };
}

That will even allow you to explicitly tell what kind of integer you want to loop with if needed:

for (auto i: range<unsigned>(0, 5))
{
    std::cout << i << " ";
}

If you need to generate indices to iterate through a std::vector, this can be useful since std::vector<T>::size_type is probably bigger than int. While the static_assert avoids some potential problems with floating point values, it also inhibits the use of integer-like classes (for example, a hypothetical BigNum class).

---

You can simplify some of your functions thanks to list initialization. For example, used in a return statement, it sallows you not to explicitly repeat the return type (unless the return type's constructor is explicit):

LoopRangeIterator begin() const
{
    return { from };
}

LoopRangeIterator end() const
{
    return { to };
}

---

On a side note, such a range utility would also be interesting if it worked with floating point numbers, and maybe decimal numbers in the future (akin to Python's numpy.arange). However, you would have to special-case the class for those types if you want to avoid problems: if you repeatedly add the same floating point (say 0.01), you will accumulate rounding errors. Computing every value from the base value with a multiplication could be away to circumvent such a problem.

Answer 3

If you have operator!=, you should also have operator== for symmetry:

bool operator==(LoopRangeIterator const& other) const
{
    return value == other.value;
}

In addition, it's more common to overload operator!= in terms of ==:

bool operator!=(LoopRangeIterator const& other) const
{
    return !(value == other.value);
}

Answer 4

I liked MORTAL's code so much I improved it. 1st, I needed it to have a template type rather than int. 2nd, I needed it to have start/stop/step with operator++ jumping by step. The resulting code (below) enables nesting loops such as:

// range code improved from MORTAL
template <typename T,T iBegin,T iEnd,T iStep=1>
class range {
    public:
        struct iterator {
            T value;
            iterator    (T v) : value(v) {}
            operator T  () const         { return value; }
            operator T& ()               { return value; }
            T operator* () const         { return value; }
            iterator& operator++ ()      { value += iStep; return *this; }
        };
        iterator begin() { return iBegin; }
        iterator end() { return iEnd; }
};

// Sample code using the improved code
for (auto jj: range<size_t,0,256,16>()) {
    for (auto ii: range<size_t,0,16>()) {
        // just show the result as a 16x16 table
        cout << hex << setw(3) << (jj+ii);
    }
    cout << endl;
}

I hope this is useful to others.

Answer 5

This example uses a nested iterator class so you don't need to have two exposed template classes. Maybe this is better - I think it's tidier

template <class T> class range {
private:
    class iter {
    private:
        T at;
    public:
        iter(T at) : at(at) {}
        bool operator!=(iter const& other) const { return at != other.at; }
        T const& operator*() const { return at; }
        iter& operator++() { ++at; return *this; }
    };

    T begin_val;
    T end_val;
public:
    range(T begin_val, T end_val) :
        begin_val(begin_val), end_val(end_val) { }
    iter begin() { return iter(begin_val); }
    iter end() { return iter(end_val); }
};

used as:

for (auto i: range<unsigned>(0, 5))
{
    std::cout << i << " ";
}

Answer 6

Preprocessor Macros! All of the loops below will produce the same result. Unfortunately, macros can't be defined more than once, so you have to give them different names.

#include <iostream>

#define irange(i,a,b) int i = (a); i < (b); ++i // if you want to use ints all the time
#define range(i,a,b) i = (a); i < (b); ++i      // if you ever want to use something other than an int
#define zrange(i,b) i = 0; i < (b); ++i       // if you want to start at zero
#define izrange(i,b) int i = 0; i < (b); ++i  // if you want to start at zero and use ints

int main ( )
{
    for ( int num = 0; num < 10; ++num ) std::cout << num << ' ';

    std::cout << '\n';

    for ( irange ( num, 0, 10 ) ) std::cout << num << ' ';

    std::cout << '\n';

    for ( int range ( num, 0, 10 ) ) std::cout << num << ' ';

    std::cout << '\n';

    for ( int zrange ( num, 10 ) ) std::cout << num << ' ';

    std::cout << '\n';

    for ( izrange ( num, 10 ) ) std::cout << num << ' ';

    std::cout << '\n';
}

You could also write more macros to do things like increment by something other than 1.