Initializer list weirdly depends on order of parameters? - c++

Question

I have the following snippet of code:
#include <type_traits>
#include <limits>
#include <initializer_list>
#include <cassert>
template <typename F, typename... FIn>
auto min_on(F f, const FIn&... v) -> typename std::common_type<FIn...>::type
{
using rettype = typename std::common_type<FIn...>::type;
rettype result = std::numeric_limits<rettype>::max();
(void)std::initializer_list<int>{((f(v) < result) ? (result = static_cast<rettype>(v), 0) : 0)...};
return result;
}
int main()
{
auto mod2 = [](int a)
{
return a % 2;
};
assert(min_on(mod2, 2) == 2); // PASSES as it should
assert(min_on(mod2, 3) == 3); // PASSES as it should
assert(min_on(mod2, 2, 3) == 3); // PASSES but shouldn't - should be 2
assert(min_on(mod2, 2, 3) == 2); // FAILS but shouldn't - should be 2
}
The idea behind template function min_on is that it should return the parameter x from list of parameters passed to it v so that it gives the smallest values for expression f(v).
The problem that I have observed is that somehow the order of parameters inside the std::initializer_list is important so the the code above will fail whereas this code:
assert(min_on(mod2, 3, 2) == 2);
will work. What might be wrong in here?

Answer 1

Your function sets result to v if f(v) < result. With mod2 as f, f(v) will only ever result in a 0, 1 or a -1. Which means that if all of your values are greater than 1, result will be set to the last v which was tested, because f(v) will always be less than result. Try putting a negative number in the middle of a bunch of positive numbers, and the negative number will always be the result, no matter where you place it.
assert(min_on(mod2, 2, 3, 4, -3, 7, 6, 5) == -3);
Perhaps you want this instead:
std::initializer_list<int>{((f(v) < f(result)) ? (result = static_cast<rettype>(v), 0) : 0)...};
The difference is I am testing f(v) < f(result), instead of f(v) < result. Although, the function is still not correct generally because it assumes that f(std::numeric_limits<rettype>::max()) is the max possible value. In the case of mod2 it works. But with something like this:
[](int a) { return -a; }
it would clearly be wrong. So perhaps you could instead require a first argument:
template <typename F, typename FirstT, typename... FIn>
auto min_on(F f, const FirstT& first, const FIn&... v)
-> typename std::common_type<FirstT, FIn...>::type
{
using rettype = typename std::common_type<FirstT, FIn...>::type;
rettype result = first;
(void)std::initializer_list<int>{((f(v) < f(result)) ? (result = static_cast<rettype>(v), 0) : 0)...};
return result;
}
Or, if you're want to avoid unnecessary calls to f:
template <typename F, typename FirstT, typename... FIn>
auto min_on(F f, const FirstT& first, const FIn&... v)
-> typename std::common_type<FirstT, FIn...>::type
{
using rettype = typename std::common_type<FirstT, FIn...>::type;
rettype result = first;
auto result_trans = f(result);
auto v_trans = result_trans;
(void)std::initializer_list<int>{(
(v_trans = f(v), v_trans < result_trans)
? (result = static_cast<rettype>(v), result_trans = v_trans, 0) : 0)...};
return result;
}