std::invoke
From cppreference.com
< cpp | utility | functional
Defined in header <functional>
|
||
template< class F, class... Args> std::invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) noexcept(/* see below */); |
(since C++17) | |
Invoke the Callable object f
with the parameters args
. As by INVOKE(std::forward<F>(f), std::forward<Args>(args)...).
where INVOKE(f, t1, t2, ..., tN) is defined as follows:
- If
f
is a pointer to member function of classT
:
- If std::is_base_of<T, std::decay_t<decltype(t1)>>::value is true, then INVOKE(f, t1, t2, ..., tN) is equivalent to (t1.*f)(t2, ..., tN)
- If std::decay_t<decltype(t1)> is a specialization of std::reference_wrapper, then INVOKE(f, t1, t2, ..., tN) is equivalent to (t1.get().*f)(t2, ..., tN)
- If
t1
does not satisfy the previous items, then INVOKE(f, t1, t2, ..., tN) is equivalent to ((*t1).*f)(t2, ..., tN).
- Otherwise, if N == 1 and
f
is a pointer to data member of classT
:
- If std::is_base_of<T, std::decay_t<decltype(t1)>>::value is true, then INVOKE(f, t1) is equivalent to t1.*f
- If std::decay_t<decltype(t1)> is a specialization of std::reference_wrapper, then INVOKE(f, t1) is equivalent to t1.get().*f
- If
t1
does not satisfy the previous items, then INVOKE(f, t1) is equivalent to (*t1).*f
- Otherwise, INVOKE(f, t1, t2, ..., tN) is equivalent to f(t1, t2, ..., tN) (that is,
f
is a FunctionObject)
Parameters
f | - | Callable object to be invoked |
args | - | arguments to pass to f
|
Exceptions
noexcept specification:
noexcept(std::is_nothrow_invocable_v<F, Args...>)
Possible implementation
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> constexpr bool is_reference_wrapper_v = is_reference_wrapper<T>::value; template <class T, class Type, class T1, class... Args> decltype(auto) INVOKE(Type T::* f, T1&& t1, Args&&... args) { if constexpr (std::is_member_function_pointer_v<decltype(f)>) { if constexpr (std::is_base_of_v<T, std::decay_t<T1>>) return (std::forward<T1>(t1).*f)(std::forward<Args>(args)...); else if constexpr (is_reference_wrapper_v<std::decay_t<T1>>) return (t1.get().*f)(std::forward<Args>(args)...); else return ((*std::forward<T1>(t1)).*f)(std::forward<Args>(args)...); } else { static_assert(std::is_member_object_pointer_v<decltype(f)>); static_assert(sizeof...(args) == 0); if constexpr (std::is_base_of_v<T, std::decay_t<T1>>) return std::forward<T1>(t1).*f; else if constexpr (is_reference_wrapper_v<std::decay_t<T1>>) return t1.get().*f; else return (*std::forward<T1>(t1)).*f; } } template <class F, class... Args> decltype(auto) INVOKE(F&& f, Args&&... args) { return std::forward<F>(f)(std::forward<Args>(args)...); } } // namespace detail template< class F, class... Args> std::invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) noexcept(std::is_nothrow_invocable_v<F, Args...>) { return detail::INVOKE(std::forward<F>(f), std::forward<Args>(args)...); }
Example
Run this code
#include <functional> #include <iostream> struct Foo { Foo(int num) : num_(num) {} void print_add(int i) const { std::cout << num_+i << '\n'; } int num_; }; void print_num(int i) { std::cout << i << '\n'; } struct PrintNum { void operator()(int i) const { std::cout << i << '\n'; } }; int main() { // invoke a free function std::invoke(print_num, -9); // invoke a lambda std::invoke([]() { print_num(42); }); // invoke a member function const Foo foo(314159); std::invoke(&Foo::print_add, foo, 1); // invoke (access) a data member std::cout << "num_: " << std::invoke(&Foo::num_, foo) << '\n'; // invoke a function object std::invoke(PrintNum(), 18); }
Output:
-9 42 314160 num_: 314159 18
See also
(C++11) |
creates a function object out of a pointer to a member (function template) |
(C++11)(removed in C++20)(C++17) |
deduces the result type of invoking a callable object with a set of arguments (class template) |
checks if a type can be invoked (as if by std::invoke) with the given argument types (class template) | |
(C++17) |
calls a function with a tuple of arguments (function template) |