Différence entre les std::result_of et decltype

Question

J'ai du mal à comprendre la nécessité d' std::result_of dans C++0x. Si j'ai bien compris, result_of est utilisé pour obtenir le type résultant de l'appel d'une fonction de l'objet avec certains types de paramètres. Par exemple:

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

Je ne vois pas vraiment la différence avec le code suivant:

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

ou

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

Le seul problème que je peux voir avec ces deux solutions, c'est que nous avons besoin de:

• avons une instance de functor pour l'utiliser dans l'expression passée à decltype.
• savoir un constructeur défini pour le foncteur.

Suis-je en droit de penser que la seule différence entre decltype et result_of c'est que le premier a besoin d'une expression, alors que le second ne l'est pas?

Answer 1

result_of a été introduit en Boost, puis inclus dans TR1, et enfin dans C++0x. Par conséquent, result_of a un avantage qui est rétro-compatible (adapté de la bibliothèque).

decltype est une toute nouvelle chose dans C++0x, ne restreint pas uniquement pour le type de retour d'une fonction, et est une fonctionnalité du langage.

---

De toute façon, sur gcc 4.5, result_of est mis en œuvre en termes 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;
    };