"Conversion" dal tipo allo stesso tipo sta causando l'errore

Question

Ho una funzione template in cui un tipo enum viene convertito nel suo tipo sottostante che funziona bene, ma ho scritto un overload che dovrebbe prendere un numero intero e restituire se stesso e dare un errore che int non è un tipo di enumerazione. Nel mio modello, questo dovrebbe essere stato filtrato. Che c'è?

Ecco il codice del modello:

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 è stato valutato in std::enable_if anche se std::is_enum<TT>::value è false come false non è un errore. Poiché un tipo di enumerazione non è in fase di valutazione, sta causando un errore. Se spostiamo la SFINAE nei parametri del modello, possiamo ottenere i sovraccarichi desiderati e restituire ancora il tipo corretto.

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; 
} 

Si può vedere che funziona in questo Live Example

Answer 2

Tentando di istanziare std::underlying_type<T> con T che non è un tipo enum, si stanno violando un requisito che la norma impone parametro di template T:

§ 20.10.7.6 [meta.trans.other]/Tabella 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. 

Ecco un approccio alternativo, se uno non piace alcun parametro di template aggiuntivi:

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; 
} 

In questo modo, l'istanza di std::underlying_type<TT> è differito fino alla condizione in std::enable_if restituisce true, perché viene richiesto un nidificato type definizione per quali resi std::enable_if<B,T>::type.

DEMO