std::invoke (3) - Linux Man Pages

std::invoke: std::invoke

NAME

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:


* If f is a pointer_to_member_function of class T:


      * 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 class T:


      * 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


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)