Método de plantilla enable_if especialización

Question

Tengo el siguiente código que no se compila. Estos son dos funciones en una clase de plantilla que toma los argumentos

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

que quieren tener una especialización en un método de la barra dependiendo de qué tipo es Ret.

¿Alguien tiene alguna idea?

Answer 1

SFINAE no funciona en funciones sin plantilla (miembro o no miembro).

Como señala Kerrek SB, las plantillas de funciones no miembro funcionarán. O, como lo señala Xeo, también les servirá crear plantillas de funciones miembro con un argumento de plantilla predeterminado.

Sin embargo, esto solo funciona porque las dos condiciones std::enable_if son sin superposición. Si desea agregar una sobrecarga diferente para int (decir), entonces verá que no se escala tan bien. Dependiendo de lo que quiere hacer, despacho etiqueta generalmente mejor que las escalas SFINAE con múltiples alternativas que desea enviar en:

#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 sólo funciona en las plantillas. El código puede ser hecho para compilar con una pequeña modificación:

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

Uso:

auto q = _on_dispatched<int>(); 

Por supuesto, puede no deducir el tipo de retorno de una función, ya que no es deducible. Sin embargo, puede empacar dentro de esta plantilla otra plantilla:

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

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