SysTutorials

Linux Manual Pages › Section 3

stdinvoke(3)

std::invoke - std::invoke

Synopsis

Defined in header <functional>
template< class F, class... Args>                                                          (since C++17)
std::invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) noexcept(/* see below */);

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:

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

mem_fn creates a function object out of a pointer to a member                           (function template) (C++11) result_of invoke_result deduces the result type of invoking a callable object with a set of arguments                           (class template) (C++11)(removed in C++20) (C++17) is_invocable is_invocable_r checks if a type can be invoked (as if by std::invoke) with the given argument types is_nothrow_invocable (class template) is_nothrow_invocable_r (C++17) apply calls a function with a tuple of arguments                           (function template) (C++17)