Diferencia entre std :: result_of y decltype

Tengo algunos problemas para comprender la necesidad de std::result_ofC ++ 0x. Si he entendido bien, result_ofse usa para obtener el tipo resultante de invocar un objeto de función con ciertos tipos de parámetros. Por ejemplo:

template <typename F, typename Arg>
typename std::result_of<F(Arg)>::type
invoke(F f, Arg a)
{
    return f(a);
}

Realmente no veo la diferencia con el siguiente código:

template <typename F, typename Arg>
auto invoke(F f, Arg a) -> decltype(f(a)) //uses the f parameter
{
    return f(a);
}

o

template <typename F, typename Arg>
auto invoke(F f, Arg a) -> decltype(F()(a)); //"constructs" an F
{
    return f(a);
}

El único problema que puedo ver con estas dos soluciones es que necesitamos:

• tener una instancia del functor para usarlo en la expresión pasada a decltype.
• conocer un constructor definido para el functor.

¿Estoy en lo cierto al pensar que la única diferencia entre decltypey result_ofes que el primero necesita una expresión mientras que el segundo no?

result_ofse introdujo en Boost y luego se incluyó en TR1 , y finalmente en C ++ 0x. Por lo tanto, result_oftiene la ventaja de que es compatible con versiones anteriores (con una biblioteca adecuada).

decltype es algo completamente nuevo en C ++ 0x, no se restringe solo al tipo de retorno de una función y es una característica del lenguaje.

De todos modos, en gcc 4.5, result_ofse implementa en términos de decltype:

  template<typename _Signature>
    class result_of;

  template<typename _Functor, typename... _ArgTypes>
    struct result_of<_Functor(_ArgTypes...)>
    {
      typedef
        decltype( std::declval<_Functor>()(std::declval<_ArgTypes>()...) )
        type;
    };

Si necesita el tipo de algo que no es algo así como una llamada de función, std::result_ofsimplemente no se aplica. decltype()puede darte el tipo de cualquier expresión.

Si nos limitamos a las diferentes formas de determinar el tipo de retorno de una llamada de función (entre std::result_of_t<F(Args...)>y decltype(std::declval<F>()(std::declval<Args>()...)), entonces hay una diferencia.

std::result_of<F(Args...) Se define como:

Si la expresión INVOKE (declval<Fn>(), declval<ArgTypes>()...)está bien formada cuando se trata como un operando no evaluado (cláusula 5), ​​el tipo de miembro typedef nombrará el tipo; de lo decltype(INVOKE (declval<Fn>(), declval<ArgTypes>()...)); contrario, no habrá ningún tipo de miembro.

La diferencia entre result_of<F(Args..)>::typey decltype(std::declval<F>()(std::declval<Args>()...)se trata de eso INVOKE. Usar declval/ decltypedirectamente, además de ser un poco más largo de escribir, solo es válido si Fse puede llamar directamente (un tipo de objeto de función o una función o un puntero de función). result_ofademás, admite punteros a funciones de miembros y punteros a datos de miembros.

Inicialmente, usar declval/ decltypegarantizaba una expresión compatible con SFINAE, mientras que std::result_ofpodría generar un error grave en lugar de un error de deducción. Eso se ha corregido en C ++ 14: std::result_ofahora se requiere que sea compatible con SFINAE (gracias a este documento ).

Entonces, en un compilador conforme a C ++ 14, std::result_of_t<F(Args...)>es estrictamente superior. Es más claro, más corto y correctamente ^† admite más Fs ^‡ .

^‡ Con excepciones. Si bien admite punteros a miembros, result_ofno funcionará si intenta crear una instancia de un identificador de tipo no válido . Estos incluirían una función que devuelve una función o que toma tipos abstractos por valor. Ex.:

template <class F, class R = result_of_t<F()>>
R call(F& f) { return f(); }

int answer() { return 42; }

call(answer); // nope

El uso correcto habría sido result_of_t<F&()>, pero ese es un detalle que no tiene que recordar decltype.