How to implicitly cast all arguments of a template function to the highest resolution type?

Question

In a project I'm working on I have a templated function similar to this where all of the arguments should be of type T

#include <iostream>

template<typename T> bool aWithinBOfC(T a, T b, T c)
{
    return std::abs(a - c) < b;
}

the issue I'm having is it won't compile if all of the arguments are not of the same type but it seems reasonable that it should implicitly cast similar types to the one with the highest resolution before evaluation. Is there any way to get a call like this to be valid?

int main()
{
    double a{1.2};
    double b{1.4};
    float c{0.1f};

    std::cout << aWithinBOfC(a, b, c) << std::endl;
}

Answer 1

Something along these lines, perhaps:

template<typename T>
bool aWithinBOfCImpl(T a, T b, T c) {
  /* actual implemenattion */
}

template <typename ... Args>
auto aWithinBOfC(Args... args) {
  return aWithinBOfCImpl<std::common_type_t<Args...>>(args...);
}

Demo

Answer 2

You don't need implicit conversions at the call site. The compiler will implicitly convert the types to the largest one in the expression in the return statement.

template <class T, class U, class V>
bool aWithinBOfC(T a, U b, V c) {
    return std::abs(a - c) < b;
}