especialización de plantilla parcial basada en "firm-ness" de tipo entero?

Question

dado:

template<typename T> 
inline bool f(T n) { 
    return n >= 0 && n <= 100; 
} 

Cuando se utiliza con un tipo de unsigned genera una advertencia:

unsigned n; 
f(n); // warning: comparison n >= 0 is always true 

¿Hay alguna manera inteligente para no hacer la comparación n >= 0 cuando T es un tipo de unsigned? He intentado añadir una especialización de plantilla parcial:

template<typename T> 
inline bool f(unsigned T n) { 
    return n <= 100; 
} 

pero gcc 4.2.1 no le gusta eso. (No creo que tipo de especialización de plantilla parcial sería legal de todos modos.)

Answer 1

Puede utilizar enable_if con el rasgo is_unsigned Tipo:

template <typename T> 
typename std::enable_if<std::is_unsigned<T>::value, bool>::type f(T n) 
{ 
    return n <= 100; 
} 

template <typename T> 
typename std::enable_if<!std::is_unsigned<T>::value, bool>::type f(T n) 
{ 
    return n >= 0 && n <= 100; 
} 

puede encontrar enable_if y is_unsigned en los espacios de nombres std o std::tr1 si su compilador soporta C++ 0x o TR1, respectivamente. De lo contrario, Boost tiene una implementación de la biblioteca de rasgos de tipo, Boost.TypeTraits. La implementación de impulso de enable_if es un poco diferente; boost::enable_if_c es similar al TR1 y C++ 0x enable_if.

Answer 2

Puede aprovechar el comportamiento de envolvente de enteros sin signo.

template<bool> struct bool_ { }; 

template<typename T> 
inline bool f(T n, bool_<false>) { 
    return n >= 0 && n <= 100; 
} 

template<typename T> 
inline bool f(T n, bool_<true>) { 
    return n <= 100; 
} 

template<typename T> 
inline bool f(T n) { 
    return f(n, bool_<(static_cast<T>(-1) > 0)>()); 
} 

Es importante no especificar >= 0, para evitar una advertencia de nuevo. A continuación aparece para engañar a GCC también

template<typename T> 
inline bool f(T n) { 
    return (n == 0 || n > 0) && n <= 100; 
} 

Answer 3

puede implementar una aplicación especial función de plantilla para unsigned tipo como:

template<class T> bool f(T val); 
template<> bool f<unsigned>(unsigned val); 

ACTUALIZACIÓN bandera sin signo

Puede aplicar diferentes implementaciones para todos tipos sin firmar que desea usar o agregue una bandera bool como:

template <class T, bool U> bool f(T val) 
{ 
     if (U) 
       return val <= 100; 
     else 
       return (val >=0) && (val <= 100); 
} 

... 

cout << f<int, false>(1) << endl; 
cout << f<int, false>(-1) << endl; 
cout << f<char, true>(10) << endl; 

Answer 4

¿Hay alguna manera inteligente de no hacer la comparación n> = 0 cuando T es un tipo sin signo? Traté de agregar una especialización de plantilla parcial:

El optimizador debería eliminar el código para la comparación ya que detectó la condición.

Para Clang, agregue -Wno-tautological-compare para desactivar la advertencia. Para GCC/G ++, agregue -Wno-type-limits para aplastar la advertencia.

Si está utilizando un compilador que admite pragma diagnostic {push|pop} puede:

#if (GCC_VERSION >= 40600) || (LLVM_CLANG_VERSION >= 10700) || (APPLE_CLANG_VERSION >= 20000) 
# define GCC_DIAGNOSTIC_AVAILABLE 1 
#endif  

#if MSC_VERSION 
# pragma warning(push) 
# pragma warning(disable: 4389) 
#endif 

#if GCC_DIAGNOSTIC_AVAILABLE 
# pragma GCC diagnostic push 
# pragma GCC diagnostic ignored "-Wsign-compare" 
# if (LLVM_CLANG_VERSION >= 20800) || (APPLE_CLANG_VERSION >= 30000) 
# pragma GCC diagnostic ignored "-Wtautological-compare" 
# elif (GCC_VERSION >= 40300) 
# pragma GCC diagnostic ignored "-Wtype-limits" 
# endif 
#endif 

template<typename T> 
inline bool f(T n) { 
    return n >= 0 && n <= 100; 
} 

#if GCC_DIAGNOSTIC_AVAILABLE 
# pragma GCC diagnostic pop 
#endif 

#if MSC_VERSION 
# pragma warning(pop) 
#endif 

ver también Comparison is always false due to limited range…