Преобразование неявного типа C++ в списках аргументов

Question

Я смущен тем, как работает неявное преобразование типов в отношении списков аргументов C++. В частности, у меня есть куча функций, называемых inRange (x, start, end), которые возвращают bool в зависимости от того, находится ли x между началом и концом.

[В этом описании InRange просто синтаксический сахар для (х> начать & & х < конца) - который по-прежнему хорошо, когда х длинная строка или дорогая функция - но в реальном коде есть дополнительные args для обработки открытого/закрытого характера границ.]

Я был расплывчатым о типах выше. В частности, существуют различные реализации для сравнения по целому и с плавающей запятой, а это означает, что шаблоны не очень уместны, поскольку нет лингвистической группы C++, которая отличает int/long/unsigned/size_t и т. Д. От float/double и т. Д. Поэтому я попытался использовать систему типов, определив две версии InRange с достаточно широкими типов INT/Float:

inline bool inRange(long x, long start, long end) 
inline bool inRange(double x, double start, double end) 

Это не поймаешь «долго долго» или подобное, но наш код использует только в большинстве двухместных и долгот. Таким образом, это выглядело довольно безопасно: я надеялся, что inRange (int, long, long) и т. Д. Неявно повысит int до конца, и все будет хорошо. Тем не менее, в случаях, когда буквенные двойники записываются sloppily для сравнения с плавающей запятой (что я хочу разрешить), например. InRange (mydouble, 10, 20), я также должен был добавить кучу явных слепков, чтобы избавиться от предупреждений компилятора и убедитесь, что используется сравнение с плавающей точкой:

inline bool inRange(double value, long low, long high) { 
    return inRange(value, (double)low, (double)high); 
} 
inline bool inRange(double value, double low, long high) { 
    return inRange(value, low, (double)high, lowbound, highbound); 
} 
... 

Не так хорошо - я бы надеялся, что преобразование длинного в двойное было бы автоматическим/неявным - но нормально. Но следующее открытие действительно исказило меня: мой компилятор обнаружил InRange с три Интсом (не лонги) в качестве аргументов, и сказал:

call of overloaded ‘inRange(int&, int&, int&)’ is ambiguous 

с последующим списком всех функции InRange определенной до сих пор! Итак, у C++ нет предпочтений (int, int, int) аргументов arg, которые должны быть разрешены (длинным, длинным, длинным), а не (двойным, двойным, двойным)? Действительно?

Любая помощь, чтобы вытащить меня из этой дыры, была бы очень признательна ... Я никогда бы не подумал, что что-то настолько простое, что только примитивные типы могут оказаться настолько трудными для решения. Создание полного набора ~ 1000 подписей функций с тремя аргументами со всеми возможными комбинациями числового типа не является ответом, на который я надеюсь!

Answer 1

Шаблоны здесь основы, вам просто нужна SFINAE.

#include <limits> 
#include <utility> 

template <typename T> 
struct is_integral { 
    static bool const value = std::numeric_limits<T>::is_integer; 
}; 

template <typename Integral, typename T> 
typename std::enable_if<is_integral<Integral>::value, bool>::type 
inRange(Integral x, T start, T end) { 
    return x >= static_cast<Integral>(start) and x <= static_cast<Integral>(end); 
} 

template <typename Real, typename T> 
typename std::enable_if<not is_integral<Real>::value, bool>::type 
inRange(Real x, T start, T end) { 
    return x >= static_cast<Real>(start) and x <= static_cast<Real>(end); 
} 

В теории, мы могли бы быть еще более мягок и просто позволить start и end иметь разные типы. Если мы хотим.

EDIT: Изменено, чтобы переключиться на реальную версию, как только есть один реальный, со встроенной проверкой работоспособности.

#include <limits> 
#include <utility> 
#include <iostream> 

template <typename T> 
struct is_integral { 
    static bool const value = std::numeric_limits<T>::is_integer; 
}; 

template <typename T> 
struct is_real { 
    static bool const value = not is_integral<T>::value; 
}; 

template <typename T, typename L, typename R> 
struct are_all_integral { 
    static bool const value = is_integral<T>::value and 
          is_integral<L>::value and 
          is_integral<R>::value; 
}; 

template <typename T, typename L, typename R> 
struct is_any_real { 
    static bool const value = is_real<T>::value or 
          is_real<L>::value or 
          is_real<R>::value; 
}; 


template <typename T, typename L, typename R> 
typename std::enable_if<are_all_integral<T, L, R>::value, bool>::type 
inRange(T x, L start, R end) { 
    typedef typename std::common_type<T, L, R>::type common; 
    std::cout << " inRange(" << x << ", " << start << ", " << end << ") -> Integral\n"; 
    return static_cast<common>(x) >= static_cast<common>(start) and 
     static_cast<common>(x) <= static_cast<common>(end); 
} 

template <typename T, typename L, typename R> 
typename std::enable_if<is_any_real<T, L, R>::value, bool>::type 
inRange(T x, L start, R end) { 
    typedef typename std::common_type<T, L, R>::type common; 
    std::cout << " inRange(" << x << ", " << start << ", " << end << ") -> Real\n"; 
    return static_cast<common>(x) >= static_cast<common>(start) and 
     static_cast<common>(x) <= static_cast<common>(end); 
} 

int main() { 
    std::cout << "Pure cases\n"; 
    inRange(1, 2, 3); 
    inRange(1.5, 2.5, 3.5); 

    std::cout << "Mixed int/unsigned\n"; 
    inRange(1u, 2, 3); 
    inRange(1, 2u, 3); 
    inRange(1, 2, 3u); 

    std::cout << "Mixed float/double\n"; 
    inRange(1.5f, 2.5, 3.5); 
    inRange(1.5, 2.5f, 3.5); 
    inRange(1.5, 2.5, 3.5f); 

    std::cout << "Mixed int/double\n"; 
    inRange(1.5, 2, 3); 
    inRange(1, 2.5, 3); 
    inRange(1, 2, 3.5); 

    std::cout << "Mixed int/double, with more doubles\n"; 
    inRange(1.5, 2.5, 3); 
    inRange(1.5, 2, 3.5); 
    inRange(1, 2.5, 3.5); 
} 

Run в ideone:

Pure cases 
    inRange(1, 2, 3) -> Integral 
    inRange(1.5, 2.5, 3.5) -> Real 
Mixed int/unsigned 
    inRange(1, 2, 3) -> Integral 
    inRange(1, 2, 3) -> Integral 
    inRange(1, 2, 3) -> Integral 
Mixed float/double 
    inRange(1.5, 2.5, 3.5) -> Real 
    inRange(1.5, 2.5, 3.5) -> Real 
    inRange(1.5, 2.5, 3.5) -> Real 
Mixed int/double 
    inRange(1.5, 2, 3) -> Real 
    inRange(1, 2.5, 3) -> Real 
    inRange(1, 2, 3.5) -> Real 
Mixed int/double, with more doubles 
    inRange(1.5, 2.5, 3) -> Real 
    inRange(1.5, 2, 3.5) -> Real 
    inRange(1, 2.5, 3.5) -> Real 

Answer 2

(Ленивый подход :) использовать шаблон функции - и пусть беспокойство компилятора об этом ..

template <typename T1> 
inline bool inRange(T1 x, T1 start, T1 end) 
{ 
    // do stuff 
} 

Это означает, что вы можете передать в любом объекте, который поддерживает operator< ... И перегрузки для конкретных типов где вы хотите сделать что-то другое (скажем std::string, const char* и т. д.)