Unterschied zwischen std :: result_of und decltype

Ich habe einige Probleme, die Notwendigkeit std::result_ofin C ++ 0x zu verstehen . Wenn ich es richtig verstanden habe, result_ofwird es verwendet, um den resultierenden Typ des Aufrufs eines Funktionsobjekts mit bestimmten Arten von Parametern zu erhalten. Beispielsweise:

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

Ich sehe den Unterschied mit dem folgenden Code nicht wirklich:

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

oder

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

Das einzige Problem, das ich bei diesen beiden Lösungen sehen kann, ist, dass wir entweder:

• Lassen Sie eine Instanz des Funktors in dem an decltype übergebenen Ausdruck verwenden.
• kennen einen definierten Konstruktor für den Funktor.

Habe ich Recht, wenn ich denke, dass der einzige Unterschied zwischen decltypeund darin result_ofbesteht, dass der erste einen Ausdruck braucht, während der zweite dies nicht tut?

result_ofwurde in Boost eingeführt und dann in TR1 und schließlich in C ++ 0x enthalten. Hat result_ofdaher einen Vorteil, der abwärtskompatibel ist (mit einer geeigneten Bibliothek).

decltype ist eine völlig neue Sache in C ++ 0x, beschränkt sich nicht nur auf den Rückgabetyp einer Funktion und ist eine Sprachfunktion.

Wie auch immer, auf gcc 4.5 result_ofist implementiert in Bezug auf 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;
    };

Wenn Sie den Typ von etwas benötigen, das nicht wie ein Funktionsaufruf ist, std::result_oftrifft dies einfach nicht zu. decltype()kann Ihnen den Typ eines beliebigen Ausdrucks geben.

Wenn wir uns nur auf die verschiedenen Methoden zur Bestimmung des Rückgabetyps eines Funktionsaufrufs (zwischen std::result_of_t<F(Args...)>und decltype(std::declval<F>()(std::declval<Args>()...)) beschränken, gibt es einen Unterschied.

std::result_of<F(Args...) ist definiert als:

Wenn der Ausdruck INVOKE (declval<Fn>(), declval<ArgTypes>()...)gut formuliert ist, wenn er als nicht bewerteter Operand behandelt wird (Abschnitt 5), benennt der Typ typedef des Mitglieds den Typ, decltype(INVOKE (declval<Fn>(), declval<ArgTypes>()...)); andernfalls gibt es keinen Elementtyp .

Der Unterschied zwischen result_of<F(Args..)>::typeund decltype(std::declval<F>()(std::declval<Args>()...)ist alles darüber INVOKE. Die Verwendung von declval/ decltypedirekt ist nicht nur etwas länger zu tippen, sondern auch nur gültig, wenn sie Fdirekt aufrufbar ist (ein Funktionsobjekttyp oder eine Funktion oder ein Funktionszeiger). result_ofunterstützt zusätzlich Zeiger auf Mitgliederfunktionen und Zeiger auf Mitgliedsdaten.

Anfänglich wird ein SFINAE-freundlicher Ausdruck verwendet declval/ decltypegarantiert, während std::result_ofdies zu einem schweren Fehler anstelle eines Abzugsfehlers führen kann. std::result_ofDies wurde in C ++ 14 korrigiert: Es muss jetzt SFINAE-freundlich sein (dank dieses Dokuments ).

Also auf einem konformen C ++ 14-Compiler std::result_of_t<F(Args...)>ist es absolut überlegen. Es ist klarer, kürzer und unterstützt ^† mehr Fs ^‡ .

^‡ Mit Ausnahmen. Es unterstützt zwar Zeiger auf Mitglieder, result_offunktioniert jedoch nicht, wenn Sie versuchen, eine ungültige Typ-ID zu instanziieren . Dazu gehört eine Funktion, die eine Funktion zurückgibt oder abstrakte Typen nach Wert nimmt. Ex.:

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

int answer() { return 42; }

call(answer); // nope

Die richtige Verwendung wäre gewesen result_of_t<F&()>, aber das ist ein Detail, an das Sie sich nicht erinnern müssen decltype.