函数预期长时返回双倍

Question

I recently answered another question and in my answer I had the following code.

template<typename T, typename ... Ts>
struct are_arithmetic{
    enum {
        value = std::is_arithmetic<T>::value && are_arithmetic<Ts...>::value
    };
};

template<typename T>
struct are_arithmetic<T>{
    enum {
        value = std::is_arithmetic<T>::value
    };
};

template<typename Arg, typename = std::enable_if_t<std::is_arithmetic<Arg>::value>>
Arg max(Arg arg){
    return arg;
}

template<typename Arg, typename Arg1, typename ... Args, typename = typename std::enable_if_t<are_arithmetic<Arg, Arg1, Args...>::value>>
auto max(Arg arg, Arg1 arg1, Args ... args){
    auto max_rest = max(arg1, args...);
    return arg > max_rest ? arg : max_rest;
}

Now, from this code I assumed that max() would return the maximum number from a given list of numbers as well as retaining its type.

But when the original poster tried the code:

int main(){
    auto res = max(1.0, 2, 3.0f, 5, 7l);
    std::cout << typeid(res).name() << " "  << typeid(7l).name();
}

He got dl from stdout.

This shows that the return type of the function isn't what expected at all. Why does the function not return a long ?

Answer 1

It seems to me that when the max () function is called as:

auto res = max(1.0, 2, 3.0f, 5, 7l);

Then given its signature:

auto max(Arg arg, Arg1 arg1, Args ... args){
    auto max_rest = max(arg1, args...);
    return arg > max_rest ? arg : max_rest;
}

Here, Arg would obviously be a double .

Then return value is a ternary operator:

return 1.0 > max_rest ? 1.0 : max_rest;

It's not important what max_rest winds out to be. Let's say it's indeed, a long . So you have a ternary operator, with one double expression, and one long expression.

Seems to me that the long expression is going to be type-promoted to a double , so the return auto type is a double .

Answer 2

The return type of

template<typename Arg, typename Arg1, typename ... Args, typename = typename std::enable_if_t<are_arithmetic<Arg, Arg1, Args...>::value>>
auto max(Arg arg, Arg1 arg1, Args ... args){
    auto max_rest = max(arg1, args...);
    return arg > max_rest ? arg : max_rest;
}

doesn't depend of value, but of given type. So here it returns the common type of all args.