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 表达式的返回类型。
|
(C++11 起) (C++14 前) |
|
(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)(C++23) |
以给定实参和可能指定的返回类型 (C++23 起)调用任意可调用 (Callable) 对象 (函数模板) |
检查类型能否以给定的实参类型调用(如同以 std::invoke) (类模板) | |
(C++11) |
获取到其实参的引用,用于不求值语境中 (函数模板) |