std::result_of, std::invoke_result - cppreference.com (original) (raw)

Deduces the return type of an INVOKE expression at compile time.

If the program adds specializations for any of the templates described on this page, the behavior is undefined.

Contents

• 1 Member types
• 2 Helper types
• 3 Possible implementation
• 4 Notes
• 5 Notes
• 6 Examples
• 7 See also

[edit] Member types

[edit] Helper types

[edit] Possible implementation

namespace detail { template struct is_reference_wrapper : std::false_type {}; template struct is_reference_wrapper<std::reference_wrapper> : std::true_type {};   template struct invoke_impl { template<class F, class... Args> static auto call(F&& f, Args&&... args) -> decltype(std::forward(f)(std::forward(args)...)); };   template<class B, class MT> struct invoke_impl<MT B::> { template<class T, class Td = typename std::decay::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::type, class = typename std::enable_if<is_reference_wrapper::value>::type> static auto get(T&& t) -> decltype(t.get());   template<class T, class Td = typename std::decay::type, class = typename std::enable_if<<B, Td>::value>::type, class = typename std::enable_if<!is_reference_wrapper::value>::type> static auto get(T&& t) -> decltype(std::forward(t));   template<class T, class... Args, class MT1, class = typename std::enable_if<std::is_function::value>::type> static auto call(MT1 B::*pmf, T&& t, Args&&... args) -> decltype((invoke_impl::get( std::forward(t)).*pmf)(std::forward(args)...));   template static auto call(MT B::*pmd, T&& t) -> decltype(invoke_impl::get(std::forward(t)).*pmd); };   template<class F, class... Args, class Fd = typename std::decay::type> auto INVOKE(F&& f, Args&&... args) -> decltype(invoke_impl::call(std::forward(f), std::forward(args)...)); } // namespace detail   // Minimal C++11 implementation: template struct result_of; template<class F, class... ArgTypes> struct result_of<F(ArgTypes...)> { using type = decltype(detail::INVOKE(std::declval(), std::declval()...)); };   // 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(), std::declval()...))), F, Args...> { using type = decltype(detail::INVOKE(std::declval(), std::declval()...)); }; } // namespace detail   template 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...> {};

[edit] Notes

As formulated in C++11, the behavior of std::result_of is undefined when INVOKE(std::declval<F>(), std::declval<ArgTypes>()...) is ill-formed (e.g. when F is not a callable type at all). C++14 changes that to a SFINAE (when F is not callable, std::result_of<F(ArgTypes...)> simply doesn't have the type member).

The motivation behind std::result_of is to determine the result of invoking a Callable, in particular if that result type is different for different sets of arguments.

F(Args...) is a function type with Args... being the argument types and F being the return type. As such, std::result_of suffers from several quirks that led to its deprecation in favor of std::invoke_result in C++17:

• F cannot be a function type or an array type (but can be a reference to them);
• if any of the Args has type "array of T" or a function type T, it is automatically adjusted to T*;
• neither F nor any of Args... can be an abstract class type;
• if any of Args... has a top-level cv-qualifier, it is discarded;
• none of Args... may be of type void.

To avoid these quirks, result_of is often used with reference types as F and Args.... For example:

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 */ }

[edit] Notes

[edit] Examples

#include #include   struct S { double operator()(char, int&); float operator()(int) { return 1.0; } };   template 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(1); // may fail to compile in C++11; calls the non-callable overload in C++14 }

Output:

overload of f for non-callable T

[edit] See also