Jak ograniczyć klasę szablonów do określonych typów wbudowanych?

Question

Ten problem był już omawiany kilka razy, ale wszystkie znalezione przeze mnie rozwiązania albo nie działały, albo były oparte na statycznym dowodzie doładowania. Mój problem jest prosty. Mam klasę i chcę tylko zezwolić na prawdziwe typy (podwójne i zmienne). Chcę, aby wystąpił błąd podczas kompilacji, gdy próbuję utworzyć instancję klasy z typem innym niż float lub double. Używam Visual C++ 11. Oto, co próbowałem:

template <typename RealType> 
class A 
{ 
    // Warning C4346 
    static_assert(std::is_same<RealType, double>::value || std::is_same<RealType, float>::value); 
} 


template <typename RealType> 
class A 
{ 
    // Error C2062: type 'unknown' unexpected 
    static_assert(decltype(RealType) == double || decltype(RealType) == float); 
} 

Wszelkie pomysły? Z góry dziękuję!

Answer 1

Jednym z rozwiązań, które widziałem jest użycie std::enable_if w aliasie typu. Coś jak:

using value_type = typename std::enable_if< 
        std::is_same<float, RealType>::value || 
        std::is_same<double, RealType>::value, 
        RealType 
       >::type; 

value_type istnieje tylko jeśli RealType jest dokładnie float lub double. W przeciwnym razie typ jest niezdefiniowany, a kompilacja nie powiedzie się.

Ostrzegam jednak, że jestem zbyt surowy w stosunku do typów. Szablony są tak potężne, jak częściowo dlatego, że pisanie przez kaczkę oznacza, że ​​każdy typ, który może być użyty w taki sposób, w jaki chcesz go użyć, zadziała. Niedozwolone typy ze względu na niedozwolone typy zazwyczaj nie zyskują dużo i mogą sprawić, że rzeczy będą mniej elastyczne niż mogłyby. Na przykład nie można użyć typu z większą precyzją, na przykład typu z dużym dziesiętnym.

Answer 2

W swoim pierwszym przykładzie static_assert należy wziąć drugi parametr, który byłby ciąg dosłowny, w przeciwnym razie uznaje się to niepowodzeniem (edit: upuszczenie drugi parametr jest legalne ponieważ C++ 17). I ten drugi argument nie może być domyślny.

Twój Drugim przykładem jest niepoprawna z kilku powodów:

• decltype ma być stosowany na wyraz, a nie na typ.
• Po prostu nie można porównywać typów z ==, prawidłowym sposobem na to jest próba pierwszej próby z std::is_same.

więc właściwa droga do tego, co staramy się osiągnąć to:

#include <type_traits> 

template <typename RealType> 
class A 
{ 
    static_assert(std::is_same<RealType, double>::value || std::is_same<RealType, float>::value, 
       "some meaningful error message"); 
}; 

Ponadto, założę się, starają się dusić szablon do pływających punktów wartości. W tym celu można użyć cechę std::is_floating_point:

#include <type_traits> 

template <typename RealType> 
class A 
{ 
    static_assert(std::is_floating_point<RealType>::value, 
       "class A can only be instantiated with floating point types"); 
}; 

I jako bonus, wziąć this online example.

Answer 3

ten sposób umożliwia również specjalizację różnych typów:

template<typename T, typename Enable = void> 
class A { 
/// Maybe no code here or static_assert(false, "nice message"); 
}; 

/// This specialization is only enabled for double or float. 
template<typename T> 
class A<T, typename enable_if<is_same<T, double>::value || is_same<T, float>::value>::type> { 

};