How to write a declarative for loop c++14 - c++

Question

Is there a way to write a declarative style for loop in C++14
for(int i = 0; i < 10; i+=2) {
// ... some code
}
The closest I have found is using boost is
for(auto i : irange(1,10,2)){
// .... some code
}
Is there a c++14/17 standards way of achieving the same effect?I was trying std::make_integer_sequence() as a possible starting point, but couldn't quite figure it out.

Answer 1

There is not a standard way of iterating over a numerical range as you desire. C++14 however allows you to create your own utilities very easily.
Approach one: numerical range.
Here's an unoptimized quickly-hacked-together example:
template <typename T>
struct num_range_itr
{
T _value, _step;
num_range_itr(T value, T step)
: _value{value}, _step{step}
{
}
auto operator*() const { return _value; }
auto operator++() { _value += _step; }
auto operator==(const num_range_itr& rhs) const { return _value == rhs._value; }
auto operator!=(const num_range_itr& rhs) const { return !(*this == rhs); }
};
template <typename T>
struct num_range
{
T _start, _end, _step;
num_range(T start, T end, T step)
: _start{start}, _end{end}, _step{step}
{
}
auto begin() const { return num_range_itr<T>{_start, _step}; }
auto end() const { return num_range_itr<T>{_end, _step}; }
};
template <typename T>
auto make_range(T start, T end, T step = 1)
{
return num_range<T>{start, end, step};
}
The code above can be used as follows:
for(auto i : make_range(0, 10, 2))
{
std::cout << i << " ";
}
// Prints: 0 2 4 6 8
Approach two: higher-order function.
Here's an unoptimized quickly-hacked-together example:
template <typename T, typename TF>
auto for_range(T start, T end, T step, TF f)
{
for(auto i = start; i < end; i += step)
{
f(i);
}
return f;
}
The code above can be used as follows:
for_range(0, 10, 2, [](auto i){ std::cout << i << " "; });
// Prints: 0 2 4 6 8
The code can be found on wandbox.
If you want to use these utilities in real projects, you need to carefully write them in order to support multiple types safely, avoid unintentional signed/unsigned conversions, avoid invalid ranges, and make sure they get optimized away.

Answer 2

std::integer_sequence will help you only if you know the size at the compilation time. I personally hate pre C++11 for-loop. It is quite easy to make a mistake by writing something like:
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++i) // very hard to spot
I use my little helper seq_t class, which I believe exactly what you need. Please note typename std::enable_if. It is to make sure it will be only used for integral types (int, uint8_t, long long etc.), but you can't use it for double or float. You can use it in three different ways:
for (int i : seq(1, 10)) // [1, 10), step 1
for (int i : seq(1, 10, 2)) // [1, 10), step 2
for (int i : seq(10)) // [0, 10), step 1
Here is my code:
#include <type_traits>
template<typename T,
typename = typename std::enable_if<std::is_integral<T>::value>::type >
class seq_t
{
T m_begin;
T m_end;
T m_step;
public:
class iterator
{
T m_curr;
T m_step;
constexpr iterator(T curr, T step)
: m_curr(curr), m_step(step)
{
}
constexpr iterator(T end)
: m_curr(end), m_step(0)
{
}
friend class seq_t;
public:
constexpr iterator& operator++()
{
m_curr += m_step;
return *this;
}
constexpr T operator*() const noexcept
{
return m_curr;
}
constexpr bool operator!=(const iterator& rhs) const noexcept
{
return this->m_curr != rhs.m_curr;
}
};
constexpr iterator begin(void) const noexcept
{
return iterator(m_begin, m_step);
}
constexpr iterator end(void) const noexcept
{
return iterator(m_end, m_step);
}
constexpr seq_t(T begin, T end, T step) noexcept
: m_begin(begin), m_end(end), m_step(step)
{
}
};
template<typename T>
inline seq_t<T>
constexpr seq(T begin, T end, T step = 1) noexcept
{
return seq_t<T>(begin, end, step);
}
template<typename T>
inline seq_t<T>
constexpr seq(T end) noexcept
{
return seq_t<T>(T{0}, end, 1);
}