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 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>()...)); }; // Conforming C++14 implementation (is also a valid C++11 implementation): 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 中所述,当 INVOKE(std::declval<F>(), std::declval<ArgTypes>()...)
格式错误时(例如当 F 本身不是可调用类型时),std::result_of
的行为未定义。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。
为了避免这些怪癖,result_of
通常与作为 F
和 Args...
的引用类型一起使用。例如
template<class F, class... Args> std::result_of_t<F&&(Args&&...)> // instead of std::result_of_t<F(Args...)>, which is wrong my_invoke(F&& f, Args&&... args) { /* implementation */ }
[编辑] 注释
特性测试 宏 | 值 | Std | 特性 |
---|---|---|---|
__cpp_lib_result_of_sfinae |
201210L | (C++14) | std::result_of 和 SFINAE |
__cpp_lib_is_invocable |
201703L | (C++17) | std::is_invocable, std::invoke_result |
[编辑] 示例
运行此代码
#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
[编辑] 另请参见
(C++17)(C++23) |
使用给定参数调用任何 Callable 对象 并可以指定返回值类型(自 C++23 起) (函数模板) |
检查类型是否可以调用(就像使用 std::invoke)并使用给定的参数类型 (类模板) | |
(C++11) |
获取模板类型参数对象的引用,用于非求值上下文 (函数模板) |