Différence entre std :: result_of et decltype

J'ai du mal à comprendre la nécessité de std::result_ofC ++ 0x. Si j'ai bien compris, result_ofest utilisé pour obtenir le type résultant de l'appel d'un objet fonction 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 vois avec ces deux solutions est que nous devons soit:

• avoir une instance du foncteur pour l'utiliser dans l'expression passée à decltype.
• connaître un constructeur défini pour le foncteur.

Ai-je raison de penser que la seule différence entre decltypeet result_ofest que le premier a besoin d'une expression alors que le second n'en a pas?

result_ofa été introduit dans Boost , puis inclus dans TR1 , et enfin dans C ++ 0x. A donc result_ofun avantage qui est rétrocompatible (avec une bibliothèque adaptée).

decltype est une chose entièrement nouvelle dans C ++ 0x, ne se limite pas uniquement au type de retour d'une fonction, et est une fonctionnalité du langage.

Quoi qu'il en soit, sur gcc 4.5, result_ofest implémenté 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;
    };

Si vous avez besoin du type de quelque chose qui ne ressemble pas à un appel de fonction, std::result_ofcela ne s'applique tout simplement pas. decltype()peut vous donner le type de n'importe quelle expression.

Si nous nous limitons aux différentes manières de déterminer le type de retour d'un appel de fonction (entre std::result_of_t<F(Args...)>et decltype(std::declval<F>()(std::declval<Args>()...)), alors il y a une différence.

std::result_of<F(Args...) est défini comme:

Si l'expression INVOKE (declval<Fn>(), declval<ArgTypes>()...)est bien formée lorsqu'elle est traitée comme un opérande non évalué (clause 5), le type typedef membre doit nommer le typedecltype(INVOKE (declval<Fn>(), declval<ArgTypes>()...)); sinon, il n'y aura pas de type de membre.

La différence entre result_of<F(Args..)>::typeet decltype(std::declval<F>()(std::declval<Args>()...)est tout à propos de cela INVOKE. L'utilisation de declval/ decltypedirectement, en plus d'être un peu plus longue à taper, n'est valide que si elle Fest directement appelable (un type d'objet fonction ou une fonction ou un pointeur de fonction).result_ofprend également en charge les pointeurs vers les fonctions des membres et les pointeurs vers les données des membres.

Initialement, utiliser declval/ decltypegaranti une expression compatible SFINAE, alors que cela std::result_ofpourrait vous donner une erreur matérielle au lieu d'un échec de déduction. Cela a été corrigé en C ++ 14: std::result_ofdoit maintenant être compatible avec SFINAE (grâce à ce papier ).

Donc, sur un compilateur C ++ 14 conforme, std::result_of_t<F(Args...)>c'est strictement supérieur. C'est plus clair, plus court et correctement ^† prend en charge plus de Fs ^‡ .

^‡ Sauf exceptions. Bien qu'il prenne en charge les pointeurs vers les membres, result_ofne fonctionnera pas si vous essayez d'instancier un type-id non valide . Celles-ci incluraient une fonction renvoyant une fonction ou prenant des types abstraits par valeur. Ex.:

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

int answer() { return 42; }

call(answer); // nope

L'utilisation correcte aurait été result_of_t<F&()>, mais c'est un détail dont vous n'avez pas à vous souvenir decltype.