std::result_of, std::invoke_result

定义于头文件 <type_traits>
template< class >

class result_of; // 不定义

template< class F, class... ArgTypes >

class result_of<F(ArgTypes...)>;
(1) (C++11 起)
(C++17 中弃用)
template< class F, class... ArgTypes>
class invoke_result;
(2) (C++17 起)

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

F 必须是可调用类型、到函数引用或到可调用类型的引用。以 ArgTypes... 调用 F 必须是良式表达式。 (C++11 起)
FArgTypes 中的所有类型可以是任何完整类型、未知边界数组或(可有 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 中弃用)
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 取代而被弃用:

为避免这些怪异,常以 FArgs... 的引用类型使用 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

参阅

(C++17)
以给定参数调用任何可调用 (Callable) 对象
(函数模板)
检查类型能否被以指定参数类型调用(如同以 std::invoke
(类模板)
(C++11)
在不求值语境中获取到其参数的引用
(函数模板)

版本历史

  • (当前 | 先前 2017年9月24日 (日) 05:52Fruderica讨论 | 贡献 . . (7,824字节) (-2). . (撤销)
  • 当前 | 先前 2017年9月24日 (日) 05:52Fruderica讨论 | 贡献. . (7,826字节) (+6,492). . (撤销)
  • 当前 | 先前 2015年11月30日 (一) 04:55P12讨论 | 贡献. . (1,334字节) (-199). . (-tr) (撤销)
  • 当前 | 先前 2015年9月23日 (三) 06:12Leedotleo讨论 | 贡献 . . (1,533字节) (0). . (撤销)
  • 当前 | 先前 2015年9月23日 (三) 06:11Leedotleo讨论 | 贡献. . (1,533字节) (0). . (撤销)
  • 当前 | 先前 2014年10月26日 (日) 18:19P12bot讨论 | 贡献 . . (1,533字节) (0). . (Fix some translations) (撤销)
  • 当前 | 先前 2013年7月2日 (二) 11:55P12bot讨论 | 贡献 . . (1,533字节) (-120). . (Use {{lc}}. Update links. Various fixes.) (撤销)
  • 当前 | 先前 2012年11月2日 (五) 14:04P12bot讨论 | 贡献 . . (1,653字节) (+217). . (r2.7.3) (机器人添加:de, en, es, fr, it, ja, pt, ru) (撤销)
  • 当前 | 先前 2012年10月27日 (六) 12:44P12讨论 | 贡献 . . (1,436字节) (0). . (1个修订: Translate from the English version) (撤销)
  • 当前 | 先前 2012年10月26日 (五) 06:00TranslationBot讨论 | 贡献. . (1,436字节) (-39). . (Translated from the English version using Google Translate) (撤销)
  • 当前 | 先前 2012年10月26日 (五) 04:09P12讨论 | 贡献 . . (1,475字节) (0). . (1个修订: Translate from the English version) (撤销)
  • 当前 | 先前) 2012年10月25日 (四) 12:00TranslationBot讨论 | 贡献. . (1,475字节) (+1,475). . (Translated from the English version using Google Translate)