"Konvertierung" vom Typ zum gleichen Typ verursacht Fehler

Question

Ich habe eine Template-Funktion, wo ein Aufzählungstyp in den zugrunde liegenden Typ konvertiert wird, die funktioniert, aber ich schrieb eine Überladung, die eine ganze Zahl nehmen und sich selbst zurückgeben sollte mir ein Fehler, dass Int kein Aufzählungstyp ist. In meiner Vorlage hätte dies herausgefiltert werden sollen. Was ist falsch? Hier

ist der Template-Code:

template <typename TT> 
    static constexpr auto get_value(TT t) 
    -> typename std::enable_if<!std::is_enum<TT>::value, TT>::type 
    { 
     return t; 
    } 

    template <typename TT> 
    static constexpr auto get_value(TT t) 
    -> typename std::enable_if<std::is_enum<TT>::value, typename std::underlying_type<TT>::type>::type 
    { 
     return (typename std::underlying_type<TT>::type)t; 
    } 

Demo

Answer 1

std::underlying_type<TT>::type wird in std::enable_if auch ausgewertet werden, obwohl std::is_enum<TT>::value ist false als false ist kein Fehler. Da ein Nicht-Aufzählungstyp ausgewertet wird, verursacht er einen Fehler. Wenn wir die SFINAE in die Template-Parameter verschieben, können wir die gewünschten Überladungen erhalten und trotzdem den korrekten Typ zurückgeben.

template <typename TT, typename std::enable_if<!std::is_enum<TT>::value, TT>::type* = nullptr> 
static constexpr auto get_value(TT t) -> TT 
{ 
    return t; 
} 

template <typename TT, typename std::enable_if<std::is_enum<TT>::value>::type* = nullptr> 
static constexpr auto get_value(TT t) -> typename std::underlying_type<TT>::type 
{ 
    return (typename std::underlying_type<TT>::type)t; 
} 

können Sie sehen es in diesem Arbeits Live Example

Answer 2

Durch den Versuch, std::underlying_type<T> mit T zu instanziiert, die nicht ein Aufzählungstyp ist, eine Anforderung verletzen, dass die Standard-T auf Template-Parameter erlegt:

§ 20.10.7.6 [meta.trans.other]/Tabelle 57:

 Template   |   Condition   |  Comments 
------------------------+---------------------------+----------------------- 
template <class T>  | T shall be an enumeration | The member typedef 
struct underlying_type; | type (7.2)    | type shall name 
         |       | the underlying type 
         |       | of T. 

Hier ist ein alternativer Ansatz, wenn man keinen zusätzlichen Template-Parameter mag:

template <typename TT> 
static constexpr auto get_value(TT t) 
    -> typename std::enable_if<!std::is_enum<TT>::value, TT>::type 
{ 
    return t; 
} 

template <typename TT> 
static constexpr auto get_value(TT t) 
    -> typename std::enable_if<std::is_enum<TT>::value 
          , std::underlying_type<TT> 
       >::type::type 
{ 
    return (typename std::underlying_type<TT>::type)t; 
} 

diese Weise wird die Instanziierung std::underlying_type<TT> aufgeschoben wird, bis die Bedingung in std::enable_if zu true auswertet, weil eine verschachtelte type Definition angefordert wird für was std::enable_if<B,T>::type zurückgibt.

DEMO