std::result_of, std::invoke_result
来自cppreference.com
| 定义于头文件 <type_traits>
|
||
| template< class > class result_of; // 不定义 |
(1) | (C++11 起) (C++17 中弃用) (C++20 中移除) |
| template< class F, class... ArgTypes> class invoke_result; |
(2) | (C++17 起) |
在编译时推导 INVOKE 表达式的返回类型。
F 必须是可调用类型、到函数引用或到可调用类型的引用。以 ArgTypes... 调用 F 必须是良式表达式。 |
(C++11 起) |
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
参阅
| (C++17) |
以给定实参调用任意可调用 (Callable) 对象 (函数模板) |
| 检查类型能否以给定的实参类型调用（如同以 std::invoke） (类模板) | |
| (C++11) |
获取到其实参的引用，用于不求值语境中 (函数模板) |