generic loop-unrolling with user-defined function - c++

Question

Recently I decided to make loop unroller. My function iterates from _Beg to _End(that are templates parameters) and calls function _func on each index:
template<size_t _Beg, size_t _End, typename _Func>
typename std::enable_if<_Beg < _End, void>::type
for_r(_Func _func)
{
_func(_Beg);
for_r<_Beg+1, _End>(_func);
}
template<size_t _Beg, size_t _End, typename _Func>
typename std::enable_if<_Beg >= _End, void>::type
for_r(_Func _func)
{}
It works ok like this:
for_r<0, 10>([](size_t index){cout << index << endl;});
However, 'index' variable is known at compile time, so it would be logically to be possible to use 'index' as constant expression in lambda. Like this:
tuple<int, int, int, int> tpl(1, 2, 3, 4);
for_r<0, 4>([&](size_t index){cout << get<index>(tpl) << endl;});
But 'index' is variable, and it is not possible to pass it into lambda as constexpr. Is there some way to deal with it and implement logical behaviour without explicitly typing loop unrolling like this:
cout << get<0>(tpl) << endl << get<1>(tpl) << endl << get<2>(tpl) << endl << get<3>(tpl) << endl;
?

Answer 1

Since 7 years passed and now we have nice features like C++17's fold expressions and C++20's explicitly templated lambdas, now it's possible to both write and use such "constexpr for"-like things easily. For example:
// Offsets std::integer_sequence by OFFSET
template <typename T, T OFFSET, T... IDXS>
constexpr std::integer_sequence<T, OFFSET + IDXS...> offset(
std::integer_sequence<T, IDXS...>)
{
return {};
}
// Calls templated operator() of given function object
// with INDEX template parameter from range [START; END)
template<std::integral T, T START, T END>
void for_constexpr_interval(auto iteration)
{
if constexpr (START >= END)
return;
[&]<T... IDXS>(std::integer_sequence<T, IDXS...>) {
(iteration.template operator()<IDXS>(), ...);
}(offset<T, START>(std::make_integer_sequence<T, END - START>()));
}
Here inside for_constexpr_interval we use explicitly templated immediately invoked lambda to introduce template parameter pack IDXS through deduction from std::integer_sequence argument (created with the help of offset function on top of std::make_integer_sequence to represent [START; END) interval) while avoiding polluting namespace with unnecessary helper functions. This pack can now be directly used by fold expression without the need to resort to recursive instantiations. In that fold expression we call iteration function object's templated operator() with appropriate template parameter. The syntax .template operator() is needed to disambiguate that operator() denotes a template, so that, e.g., following < is not interpreted as "less than" sign.
It can be used like this:
std::tuple tpl(1, 2, 3, 4);
for_constexpr_interval<size_t, 0, 4>([&]<size_t INDEX>() {
if constexpr (INDEX > 0)
std::cout << ' ';
std::cout << std::get<INDEX>(tpl);
});
std::cout << std::endl;
for_constexpr_interval<int, -1, 2>([&]<int INDEX>() {
std::cout << INDEX << std::endl;
});
Godbolt
Note that when passing function objects to for_constexpr_interval we yet again utilise explicitly templated lambdas. Also, it can be seen from the generated assembly that even at -O1 optimisations calls in main get inlined, which happens at least for the latest GCC, Clang and MSVC. If needed, inlining can be forced by compiler-specific attributes/specifiers (on any combination of for_constexpr_interval, inner immediately invoked lambda, passed lambda), though usually such decisions are better left to compiler.
Finally, for_constexpr_interval can be changed/generalized/supplemented further, e.g. by allowing reverse traversal of indices, STEP (increment) argument or non-std::integral index types, but this will require more complex implementation for creating sequence of indices in inner lambda's argument (probably abandoning std::make_integer_sequence for custom alternative) and some care for floating-point indices.