¿Cómo deducir el tipo de valor de retorno del funtor?

Question

Me gustaría escribir una función de plantilla que acepte 2 valores y un funtor o una lambda. La función llama al funtor con esos valores y devuelve el resultado.

template <typename T, typename Fn> 
_ReturnTypeOfPred_ Apply(T x, T y, Fn fn) 
    { 
    return fn(x, y); 
    } 

Pregunta: ¿Cómo puedo definir el tipo de retorno de Apply para convertirse igual al tipo de retorno de Fn? No es necesariamente igual a T, como en este ejemplo del funtor

template <typename T> 
auto Sum(T x, T y) -> decltype(x+y) 
    { 
    return x+y; 
    } 

actualización

fue demasiado simplificado El primero ejemplo. ¿Debería funcionar esta?

template <typename TContainer, typename Fn> 
auto Apply(const TContainer& x, const TContainer& y, Fn fn) -> decltype(fn(x.front(), y.front())) 
    { 
    return fn(x.front(), y.front()); 
    } 

¿Sería siempre funciona si repito return expresión en decltype del tipo de cambio? ¿Hay una manera más elegante?

Answer 1

Estás cerca; sólo tiene que utilizar decltype:

template <typename T, typename Fn> 
auto Apply(T x, T y, Fn fn) -> decltype(fn(x, y)) 
{ 
    return fn(x, y); 
} 

Usted podría utilizar std::result_of (Difference between std::result_of and decltype), pero ¿por qué preocuparse?

template <typename T, typename Fn> 
typename std::result_of<Fn, T, T>::type Apply(T x, T y, Fn fn) 
{ 
    return fn(x, y); 
} 

---

En cuanto a la pregunta de seguimiento: para una función

auto fn(<args>) -> <return-type> { return <expression>; } 

sustituyendo return-type con decltype(<expression>) se generalmente trabajo, pero puede ser propenso a errores. Por ejemplo, considere:

auto f(char c) -> decltype(std::string() += c) { return std::string() += c; } 

Aquí decltype rendirá std::string & y su función devolverá una referencia lvalue a un local! Esto tendría que ser cambiado a:

auto f(char c) -> std::remove_reference<decltype(std::string() += c)>::type { 
    return std::string() += c; 
} 

En otros casos, <expression> podría producir un valor que no es retornable para razón de ser, por ejemplo, no copiable, que contiene una lambda, etc.