Metodo template enable_if specializzazione

Question

Ho il seguente codice che non viene compilato. Questo sono due funzioni in una classe template che prende gli argomenti

typename std::enable_if<std::is_void<Ret>::value, Ret>::type _on_dispatched() { 
    // ... 
} 

typename std::enable_if<!std::is_void<Ret>::value, Ret>::type _on_dispatched() { 
    // .... 
} 

voglio avere una specializzazione in un metodo membro a seconda del tipo Ret è.

Qualcuno ha qualche idea?

Answer 1

SFINAE non funziona su funzioni non modello (membro o non membro).

Come sottolinea Kerrek SB, far funzionare i modelli di funzioni non membri. O come indicato da Xeo, anche i template delle funzioni membro con un argomento template predefinito funzioneranno.

Tuttavia, questo funziona solo perché le due condizioni sono std::enable_ifnon sovrapposti. Se si desidera aggiungere un sovraccarico diverso per int (ad esempio), si scoprirà che non viene ridimensionato in modo corretto. A seconda di cosa si vuole fare, tag di dispacciamento in genere scale meglio di SFINAE con molteplici alternative che si desidera inviare a:

#include<type_traits> 

template<typename Ret> 
class Foo 
{ 
public: 
    void _on_dispatched() 
    { 
     // tag dispachting: create dummy of either std::false_type or std::true_type 
     // almost guaranteed to be optimized away by a decent compiler 
     helper_on_dispatched(std::is_void<Ret>()); 
    } 

private: 
    void helper_on_dispatched(std::false_type) 
    { 
     // do stuff for non-void 
    } 

    void helper_on_dispatched(std::true_type) 
    { 
     // do stuff for void 
    } 
}; 

int main() 
{ 
    Foo<void>()._on_dispatched(); 
    Foo<int>()._on_dispatched(); 
    return 0; 
} 

Answer 2

SFINAE funziona solo su modelli. Il tuo codice può essere fatto per compilare con una piccola modifica:

template <typename Ret> 
typename std::enable_if<std::is_void<Ret>::value, Ret>::type _on_dispatched() { /*...*/ } 

template <typename Ret> 
typename std::enable_if<!std::is_void<Ret>::value, Ret>::type _on_dispatched() { /*...*/ } 

Usage:

auto q = _on_dispatched<int>(); 

È possibile, naturalmente, non dedurre il tipo di ritorno di una funzione, dal momento che non è deducibile. Tuttavia, è possibile confezionare questo modello all'interno un altro modello:

template <typename T> 
struct Foo 
{ 
    // insert templates here, maybe privately so 

    T bar() { return _on_dispatched<T>(); } 
};