# std::result_of, std::invoke_result

< cpp‎ | types

定义于头文件 `<type_traits>` |  |
template< class > class result_of; // 不定义 template< class F, class... ArgTypes > class result_of<F(ArgTypes...)>; | (1) | (C++11 起) (C++17 中弃用) (C++20 中移除)
template< class F, class... ArgTypes> class invoke_result; | (2) | (C++17 起)

在编译时推导 INVOKE 表达式的返回类型。

`F` 必须是可调用类型、到函数引用或到可调用类型的引用。以 `ArgTypes...` 调用 `F` 必须是良构表达式。 | (C++11 起) (C++14 前)
`F` 和 `ArgTypes` 中的所有类型可以是任何完整类型、未知边界数组或（可有 cv 限定的） `void` | (C++14 起)

添加此页面上描述的任何模板的特化的程序行为未定义。

### 成员类型

成员类型 | 定义
`type` | 若以参数 `ArgTypes...` 调用可调用 (Callable) 类型 `F` 的返回类型。仅若 `F` 能以参数 `ArgTypes...` 在不求值语境中调用才得到定义。 (C++14 起)

### 辅助类型

template< class T > using result_of_t = typename result_of<T>::type; | (1) | (C++14 起) (C++17 中弃用) (C++20 中移除)
template< class F, class... ArgTypes> using invoke_result_t = typename invoke_result<F, ArgTypes...>::type; | (2) | (C++17 起)

### 可能的实现

    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 Base, class T, class Derived, class... Args>
    auto INVOKE(T Base::*pmf, Derived&& ref, Args&&... args)
     -> typename std::enable_if<std::is_function<T>::value &&
                         std::is_base_of<Base, typename std::decay<Derived>::type>::value,
        decltype((std::forward<Derived>(ref).*pmf)(std::forward<Args>(args)...))>::type;

    template <class Base, class T, class RefWrap, class... Args>
    auto INVOKE(T Base::*pmf, RefWrap&& ref, Args&&... args)
     -> typename std::enable_if<std::is_function<T>::value &&
                         is_reference_wrapper<typename std::decay<RefWrap>::type>::value,
        decltype((ref.get().*pmf)(std::forward<Args>(args)...))>::type;

    template <class Base, class T, class Pointer, class... Args>
    auto INVOKE(T Base::*pmf, Pointer&& ptr, Args&&... args)
     -> typename std::enable_if<std::is_function<T>::value &&
                         !is_reference_wrapper<typename std::decay<Pointer>::type>::value &&
                         !std::is_base_of<Base, typename std::decay<Pointer>::type>::value,
        decltype(((*std::forward<Pointer>(ptr)).*pmf)(std::forward<Args>(args)...))>::type;

    template <class Base, class T, class Derived>
    auto INVOKE(T Base::*pmd, Derived&& ref)
     -> typename std::enable_if<!std::is_function<T>::value &&
                         std::is_base_of<Base, typename std::decay<Derived>::type>::value,
        decltype(std::forward<Derived>(ref).*pmd)>::type;

    template <class Base, class T, class RefWrap>
    auto INVOKE(T Base::*pmd, RefWrap&& ref)
     -> typename std::enable_if<!std::is_function<T>::value &&
                         is_reference_wrapper<typename std::decay<RefWrap>::type>::value,
        decltype(ref.get().*pmd)>::type;

    template <class Base, class T, class Pointer>
    auto INVOKE(T Base::*pmd, Pointer&& ptr)
     -> typename std::enable_if<!std::is_function<T>::value &&
                         !is_reference_wrapper<typename std::decay<Pointer>::type>::value &&
                         !std::is_base_of<Base, typename std::decay<Pointer>::type>::value,
        decltype((*std::forward<Pointer>(ptr)).*pmd)>::type;

    template <class F, class... Args>
    auto INVOKE(F&& f, Args&&... args)
     -> typename std::enable_if<!std::is_member_pointer<typename std::decay<F>::type>::value,
        decltype(std::forward<F>(f)(std::forward<Args>(args)...))>::type;
    } // namespace detail

    // 最小 C++11 实现：
    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>()...));
    };

    // 符合 C++14 的实现（亦为合法的 C++11 实现）：
    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...> {};

### 注解

在 C++11 中规范时， `std::result_of` 的行为在 `INVOKE(std::declval<F>(), std::declval<ArgTypes>()...)` 为病式时（例如 F 完全不可调用时）未定义。 C++14 更改为 SFINAE （ F 不可调用时， `std::result_of<F(ArgTypes...)>` 简单地无 `type` 成员）。

`std::result_of` 后的动机是确定调用可调用 (Callable) 类型的结果，尤其是结果类型对不同参数集不同的情况。

F(Args...) 是以 `Args...` 为参数而以 `F` 为返回类型的函数类型。因而， `std::result_of` 承受了许多怪异，导致它在 C++17 中被 `std::invoke_result` 取代而被弃用：

- `F` 不能是函数类型或数组类型（但能是到它们的引用）；
- 若任何 `Args` 拥有“ `T` 的数组”类型或函数类型 `T` ，则它被自动调整为 `T*` ；
- `F` 或任何 `Args...` 都不能是抽象类类型；
- 若任何 `Args...` 拥有顶层 cv 限定符，则舍弃之；
- `Args...` 均不可为 void 。

为避免这些怪异，常以 `F` 和 `Args...` 的引用类型使用 `result_of` 。例如：

    template<class F, class... Args>
    std::result_of_t<F&&(Args&&...)> // 替代错误的 std::result_of_t<F(Args...)>
      my_invoke(F&& f, Args&&... args) {
        /* implementation */
    }

### 示例

    #include <type_traits>
    #include <iostream>

    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()
    {
        // 以 char 和 int 参数调用 S 的结果是 double
        std::result_of<S(char, int&)>::type d = 3.14; // d 拥有 double 类型
        static_assert(std::is_same<decltype(d), double>::value, "");

        // 以 int 参数调用 S 的结果是 float
        std::result_of<S(int)>::type x = 3.14; // x 拥有 float 类型
        static_assert(std::is_same<decltype(x), float>::value, "");

        // result_of 能以指向成员函数的指针以如下方式使用
        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); // C++11 中可能编译失败； C++14 中调用不可调用重载
    }

输出：

    overload of f for non-callable T

### 参阅

invoke invoke_r (C++17)(C++23) | 以给定实参和可能指定的返回类型 (C++23 起)调用任意可调用 (Callable) 对象 (函数模板)
is_invocable is_invocable_r is_nothrow_invocable is_nothrow_invocable_r (C++17) | 检查类型能否以给定的实参类型调用（如同以 std::invoke） (类模板)
declval (C++11) | 获取到其实参的引用，用于不求值语境中 (函数模板)