std:: result_of, std:: invoke_result

Leitet den Rückgabetyp eines INVOKE Ausdrucks zur Kompilierzeit ab.

Wenn das Programm Spezialisierungen für irgendwelche der auf dieser Seite beschriebenen Templates hinzufügt, ist das Verhalten undefiniert.

Mitgliedertypen

Hilfstypen

Mögliche Implementierung

namespace detail
{
    template<class T>
    struct is_reference_wrapper : std::false_type {};
    template<class U>
    struct is_reference_wrapper<std::reference_wrapper<U>> : std::true_type {};
    template<class T>
    struct invoke_impl
    {
        template<class F, class... Args>
        static auto call(F&& f, Args&&... args)
            -> decltype(std::forward<F>(f)(std::forward<Args>(args)...));
    };
    template<class B, class MT>
    struct invoke_impl<MT B::*>
    {
        template<class T, class Td = typename std::decay<T>::type,
            class = typename std::enable_if<std::is_base_of<B, Td>::value>::type>
        static auto get(T&& t) -> T&&;
        template<class T, class Td = typename std::decay<T>::type,
            class = typename std::enable_if<is_reference_wrapper<Td>::value>::type>
        static auto get(T&& t) -> decltype(t.get());
        template<class T, class Td = typename std::decay<T>::type,
            class = typename std::enable_if<!std::is_base_of<B, Td>::value>::type,
            class = typename std::enable_if<!is_reference_wrapper<Td>::value>::type>
        static auto get(T&& t) -> decltype(*std::forward<T>(t));
        template<class T, class... Args, class MT1,
            class = typename std::enable_if<std::is_function<MT1>::value>::type>
        static auto call(MT1 B::*pmf, T&& t, Args&&... args)
            -> decltype((invoke_impl::get(
                std::forward<T>(t)).*pmf)(std::forward<Args>(args)...));
        template<class T>
        static auto call(MT B::*pmd, T&& t)
            -> decltype(invoke_impl::get(std::forward<T>(t)).*pmd);
    };
    template<class F, class... Args, class Fd = typename std::decay<F>::type>
    auto INVOKE(F&& f, Args&&... args)
        -> decltype(invoke_impl<Fd>::call(std::forward<F>(f),
            std::forward<Args>(args)...));
} // namespace detail
// Minimal C++11 implementation:
template<class> struct result_of;
template<class F, class... ArgTypes>
struct result_of<F(ArgTypes...)>
{
    using type = decltype(detail::INVOKE(std::declval<F>(), std::declval<ArgTypes>()...));
};
// Konforme C++14-Implementierung (ist ebenfalls eine gültige C++11-Implementierung):
namespace detail
{
    template<typename AlwaysVoid, typename, typename...>
    struct invoke_result {};
    template<typename F, typename...Args>
    struct invoke_result<
        decltype(void(detail::INVOKE(std::declval<F>(), std::declval<Args>()...))),
            F, Args...>
    {
        using type = decltype(detail::INVOKE(std::declval<F>(), std::declval<Args>()...));
    };
} // namespace detail
template<class> struct result_of;
template<class F, class... ArgTypes>
struct result_of<F(ArgTypes...)> : detail::invoke_result<void, F, ArgTypes...> {};
template<class F, class... ArgTypes>
struct invoke_result : detail::invoke_result<void, F, ArgTypes...> {};

Hinweise

Wie in C++11 formuliert, ist das Verhalten von std::result_of undefiniert, wenn INVOKE(std::declval<F>(), std::declval<ArgTypes>()...) ill-formed ist (z.B. wenn F überhaupt kein aufrufbarer Typ ist). C++14 ändert dies zu einem SFINAE (wenn F nicht aufrufbar ist, hat std::result_of<F(ArgTypes...)> einfach kein type -Member).

Die Motivation hinter std::result_of ist es, das Ergebnis des Aufrufs eines Callable zu bestimmen, insbesondere wenn dieser Ergebnistyp für verschiedene Argumentmengen unterschiedlich ist.

F ( Args... ) ist ein Funktionstyp, bei dem Args... die Argumenttypen und F den Rückgabetyp darstellt. Daher weist std::result_of mehrere Eigenheiten auf, die zur Ablösung durch std::invoke_result in C++17 führten:

• F kann kein Funktionstyp oder Array-Typ sein (kann jedoch eine Referenz darauf sein);
• falls einer der Args den Typ "Array von T " oder einen Funktionstyp T hat, wird er automatisch zu T* angepasst;
• weder F noch einer von Args... kann ein abstrakter Klassentyp sein;
• falls einer von Args... einen Top-Level-cv-Qualifizierer hat, wird dieser verworfen;
• keiner von Args... darf vom Typ void sein.

Um diese Eigenheiten zu vermeiden, result_of wird oft mit Referenztypen für F und Args... verwendet. Zum Beispiel:

template<class F, class... Args>
std::result_of_t<F&&(Args&&...)> // anstelle von std::result_of_t<F(Args...)>, was falsch ist
    my_invoke(F&& f, Args&&... args)
    {
        /* Implementierung */
    }

Hinweise

Beispiele

#include <iostream>
#include <type_traits>
struct S
{
    double operator()(char, int&);
    float operator()(int) { return 1.0; }
};
template<class T>
typename std::result_of<T(int)>::type f(T& t)
{
    std::cout << "overload of f for callable T\n";
    return t(0);
}
template<class T, class U>
int f(U u)
{
    std::cout << "overload of f for non-callable T\n";
    return u;
}
int main()
{
    // the result of invoking S with char and int& arguments is double
    std::result_of<S(char, int&)>::type d = 3.14; // d has type double
    static_assert(std::is_same<decltype(d), double>::value, "");
    // std::invoke_result uses different syntax (no parentheses)
    std::invoke_result<S,char,int&>::type b = 3.14;
    static_assert(std::is_same<decltype(b), double>::value, "");
    // the result of invoking S with int argument is float
    std::result_of<S(int)>::type x = 3.14; // x has type float
    static_assert(std::is_same<decltype(x), float>::value, "");
    // result_of can be used with a pointer to member function as follows
    struct C { double Func(char, int&); };
    std::result_of<decltype(&C::Func)(C, char, int&)>::type g = 3.14;
    static_assert(std::is_same<decltype(g), double>::value, "");
    f<C>(1); // may fail to compile in C++11; calls the non-callable overload in C++14
}

overload of f for non-callable T

Siehe auch