specjalizacja szablonu struct dla integralnych/Rynek typów

Question

Chcę utworzyć weryfikatorów dla liczby różnego rodzaju (Integer, punkty pływających) np .:

typename number_validator<T>::type validator; 

znalazłem użyteczne cechy w std tj is_integral i is_floating_point. Jak mogę wykorzystać te cechy, aby specjalizować szablon number_validator (to jest struct)?

edit: szukam czegoś takiego:

template<typename T, typename Enabled> 
struct number_validator {}; 

template<typename T> 
struct number_validator<T, typename enable_if<is_floating_point<T>::value, T>::type> 
//this doesn't work.. 
{ 
    typedef floating_point_validator type; 
}; 

Answer 1

To może być to, czego szukasz, to znaczy tag wysyłki:

template<typename T, bool = is_integral<T>::value> 
struct number_validator {}; 

template<typename T> 
struct number_validator<T, true> 
{ 
    typedef integral_validator type; 
}; 

template<typename T> 
struct number_validator<T, false> 
{ 
    typedef floating_point_validator type; 
}; 

ta zakłada, że ​​naprawdę można operować na liczbach, więc typy są zawsze albo całkowite lub zmiennoprzecinkowe.

Answer 2

Nie trzeba nawet tych, w tym przypadku, można właściwie tylko specjalizują się szablony jak ten.

template <typename T> 
struct number_validator; 
template <> 
struct number_validator<float>; 

template <> 
struct number_validator<int>; 

template <> 
struct number_validator<double>; 

Będzie specjalizować swój numer walidator dla każdego typu, to wymaga, aby wymienić wszystkie integralne i pływających typy punktów. Można też zrobić coś takiego:

#include <type_traits> 
#include <iostream> 
template<class T> 
typename std::enable_if<std::is_floating_point<T>::value,T>::type func(T t) { 
    std::cout << "You got a floating point" << std::endl; 
    return t; 
} 

template<class T> 
typename std::enable_if<std::is_integral<T>::value,T>::type func(T t) { 
    std::cout << "You got an Integral" <<std::endl; 
    return t; 
} 

int main() { 
    float f = func(1.0); 
    int a = func(2); 
} 

Answer 3

Można to zrobić za pomocą liczb całkowitych:

template <typename T, bool isIntegral = std::is_integral<T>::value> 
struct number_validator 
{ 
    typedef WhatEverType type; 
}; 

template <typename T> 
struct number_validator<T, true> 
{ 
    typedef WhatEverTypeInt type; 
}; 

Druga specjalizacja zostanie wybrany, jeśli jest liczbą całkowitą, ale nie wiem co jeśli jest to zmiennoprzecinkowy lub inny typ.