Metoda szablonowa enable_if specjalizacja

Question

Mam następujący kod, który się nie kompiluje. To są dwie funkcje w klasie szablonu, że trwa argumentów

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() { 
    // .... 
} 

chcę mieć specjalizację w sposobie zarejestrował się w zależności od rodzaju Ret jest.

Czy ktoś ma jakiś pomysł?

Answer 1

SFINAE nie działa w przypadku funkcji innych niż szablony (członek lub członek).

Jak wskazuje Kerrek SB, ich szablony funkcjonalne nie będące członkami będą działać. Lub, jak zaznacza Xeo, działa również szablonów funkcji członkowskich z domyślnym argumentem szablonu.

Działa to jednak tylko dlatego, że dwa warunki: std::enable_if to nienakładające się na siebie. Jeśli chcesz dodać inne przeciążenie dla int (powiedzmy), przekonasz się, że nie skaluje się tak ładnie. W zależności od tego, co chcesz zrobić, tag dyspozytorskich zazwyczaj skaluje lepiej niż SFINAE z wieloma alternatywami, które chcesz wysyłkę na:

#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 działa tylko na szablonach. Kod można skompilować z małą modyfikacją:

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() { /*...*/ } 

Zastosowanie:

auto q = _on_dispatched<int>(); 

Można oczywiście nie wywnioskować typ zwracanej przez funkcję, ponieważ nie jest to wywnioskować. Jednak można zapakować ten szablon wewnątrz kolejny szablon:

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

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