# 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 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 (C++11) | creates a function object out of a pointer to a member (function template)
result_ofinvoke_result (C++11)(removed in C++20)(C++17) | deduces the result type of invoking a callable object with a set of arguments (class template)
is_invocableis_invocable_ris_nothrow_invocableis_nothrow_invocable_r (C++17) | checks if a type can be invoked (as if by std::invoke) with the given argument types (class template)
apply (C++17) | calls a function with a tuple of arguments (function template)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/functional/invoke&oldid=105562"