¿Cómo verificar que el tipo de parámetro de la plantilla sea integral?

Question

En la descripción de alguna función de plantilla std vi algo como:

si el parámetro de plantilla es de tipo integral, el comportamiento es tal y tal.
de lo contrario, es tal y tal.

¿Cómo puedo hacer una prueba similar? Quizás dynamic_cast?

Dado que la función que escribo es para mi uso personal, puedo confiar en mí solo para proporcionar los parámetros correctos, pero ¿por qué perder la oportunidad de aprender algo? :)

Answer 1

Además de las otras respuestas, debe tenerse en cuenta que la prueba se puede utilizar en tiempo de ejecución, sino también en tiempo de compilación para seleccionar la aplicación correcta dependiendo de carnero el tipo es integral o no:

versión

tiempo de ejecución :

// Include either <boost/type_traits/is_integral.hpp> (if using Boost) 
// or <type_traits> (if using c++1x) 
// In the following, is_integral shoudl be prefixed by either boost:: or std:: 

template <typename T> 
void algorithm(const T & t) 
{ 
    // some code 

    if (is_integral<T>::value) 
    { 
     // operations to perform if T is an integral type 
    } 
    else 
    { 
     // operations to perform if T is not an integral type 
    } 

    // some other code 
} 

Sin embargo, esta solución se puede mejorar cuando la implementación del algoritmo depende en gran medida de la prueba. En este caso, tendríamos la prueba en la parte superior de la función, luego un gran bloque then y un gran bloque else. Un enfoque común en este caso es sobrecargar la función y hacer que el compilador seleccione la implementación correcta utilizando SFINAE. Una manera fácil de hacer esto es utilizar boost::enable_if:

#include <boost/utility/enable_if.hpp> 
#include <boost/type_traits/is_integral.hpp> 

template <typename T> 
typename boost::enable_if<boost::is_integral<T> >::type 
algorithm(const T & t) 
{ 
    // implementation for integral types 
} 

template <typename T> 
typename boost::disable_if<boost::is_integral<T> >::type 
algorithm(const T & t) 
{ 
    // implementation for non integral types 
} 

Cuando se invoca la función algorithm, el compilador "seleccionar" a la aplicación correcta en función de carnero el parámetro de plantilla es integral o no.

Answer 2

One possibility:

#include <type_traits> 
#include <iostream> 

struct trivial 
{ 
    int val; 
}; 

int main() 
{ 
    std::cout << "is_integral<trivial> == " << std::boolalpha 
     << std::is_integral<trivial>::value << std::endl; 
    std::cout << "is_integral<int> == " << std::boolalpha 
     << std::is_integral<int>::value << std::endl; 
    std::cout << "is_integral<float> == " << std::boolalpha 
     << std::is_integral<float>::value << std::endl; 

    return (0); 
} 

Así que posteriormente utiliza std::is_integral<> para determinar la acción.

Answer 3

Boost.TypeTraits proporciona is_integral <>(), como se describe en otra respuesta, si su compilador aún no admite las características de C++ del siguiente estándar.

Answer 4

Si no puede usar las funciones de C++ 11, std::numeric_limits<T>::is_integer hace the same thing como std::is_integral<T>::value, y está disponible con C++ 98.

Tenga en cuenta que la versión 98 es inte ger, no inte gral.