std::max behaves unexpected with uniform initialization and constexpr int

Question

I am experimenting with std::max. I am tring to pass integers constexpr with uniform initialization (curly braces), to compare them to floating-point variables.

Experiment a): Call std::max() with double/int mixed

    double a = 3.0;
    int b = 5;
    auto res = std::max(a, b);

Does not compile. Clang reports error: no matching function for call to 'max'. This is of course OK.

Experiment b): Use curly braces + constexpr int for non-anrrowing conversion

    double a = 3.0;
    constexpr int b = 5;
    auto res = std::max(a, {b});

Compiles and works as expected: returns a double with value 5.0.

Experiment c): Same as b) but swap arguments of std::max.

    double a = 3.0;
    constexpr int b = 5;
    auto res = std::max({b}, a);

Does not compile both under gcc and clang. Why?

Clang reports error: called object type 'double' is not a function or function pointer.

std::max<double>(a, b) should work. max(a, b) doesn't compile because the compiler cannot deduce the template parameter - one argument says it's int, the other says it's double. Putting {b} in curly braces makes it non-deduced context, removing the ambiguity; the template parameter is now successfully deduced from a alone. — Igor Tandetnik
@cigien You are not including <algorithm> which is required to make std::max available. — walnut

walnut walnut · Accepted Answer · 2020-04-12T15:27:54

There exists an overload of std::max that looks like this (from cppreference.com):

template< class T, class Compare >
constexpr T max( std::initializer_list<T> ilist, Compare comp );

This is a better match for your call auto res = std::max({b}, a); than

template< class T >
constexpr const T& max( const T& a, const T& b );

which you are trying to call, since the {b} can be deduced to std::initializer_list<int> and that call has exact match conversion rank in both arguments, while the overload that you want to call requires a conversion from int to double which is not exact match.

The second argument is then considered the Compare functor to be called for the comparison operation, but calling a double fails obviously. The overload is not disabled if the second argument is not callable, which is why it is still chosen.

This doesn't happen with auto res = std::max(a, {b});, because there is no overload with std::initializer_list parameter for the second argument and so only the overload that you want to call is viable. The initializer list makes the second parameter a non-deduced context, which is why it works in contrast to auto res = std::max(a, b);, which fails due to template argument deduction mismatch between the two arguments.

std::max behaves unexpected with uniform initialization and constexpr int

2 Answers