# std::invoke, std::invoke_r

< cpp‎ | utility‎ | functional

定义于头文件 `<functional>` |  |
| (1) |
template< class F, class... Args > std::invoke_result_t<F, Args...> invoke( F&& f, Args&&... args ) noexcept(/* see below */); |  | (C++17 起) (C++20 前)
template< class F, class... Args > constexpr std::invoke_result_t<F, Args...> invoke( F&& f, Args&&... args ) noexcept(/* see below */); |  | (C++20 起)
template< class R, class F, class... Args > constexpr R invoke_r(F&& f, Args&&... args) noexcept(/* see below */); | (2) | (C++23 起)

1) 以参数 `f` 调用可调用 (Callable) 对象。如同以 INVOKE(std::forward<F>(f), std::forward<Args>(args)...) 。此重载仅若 std::is_invocable_v<F, Args...> 为 true 才参与重载决议。
2) 同 (1) ，除了若 `R` 不是可为 cv 限定的 void 则将结果隐式转换到 `R` ，否则舍弃结果。此重载仅若 std::is_invocable_r_v<R, F, Args...> 为 true 才参与重载决议。

操作 INVOKE(f, t1, t2, ..., tN) 定义如下：

- 若 `f` 是类 `T` 的指向成员函数的指针：

  - 若 std::is_base_of<T, std::decay_t<decltype(t1)>>::value 为 true ，则 INVOKE(f, t1, t2, ..., tN) 等价于 (t1.*f)(t2, ..., tN)
  - 若 std::decay_t<decltype(t1)> 是 std::reference_wrapper 的特化，则 INVOKE(f, t1, t2, ..., tN) 等价于 (t1.get().*f)(t2, ..., tN)
  - 若 `t1` 不满足前述项目，则 INVOKE(f, t1, t2, ..., tN) 等价于 ((*t1).*f)(t2, ..., tN).

- 否则，若 N == 1 且 `f` 是类 `T` 的指向数据成员的指针：

  - 若 std::is_base_of<T, std::decay_t<decltype(t1)>>::value 为 true ，则 INVOKE(f, t1) 等价于 t1.*f
  - 若 std::decay_t<decltype(t1)> 是 std::reference_wrapper 的特化，则 INVOKE(f, t1) 等价于 t1.get().*f
  - 若 `t1` 不满足前述项目，则 INVOKE(f, t1) 等价于 (*t1).*f

- 否则， INVOKE(f, t1, t2, ..., tN) 等价于 f(t1, t2, ..., tN) （即 `f` 是一个函数对象 (FunctionObject) ）

### 参数

f | - | 要调用的可调用 (Callable) 对象
args | - | 传递给 `f` 的参数

### 返回值

1) `f` 返回的值。
2) `f` 返回的值隐式转换成 `R` ，若 `R` 不是 void 。否则为无。

### 异常

1)
`noexcept` 说明：
noexcept(std::is_nothrow_invocable_v<F, Args...>)
2)
`noexcept` 说明：
noexcept(std::is_nothrow_invocable_r_v<R, F, Args...>)

### 可能的实现

版本一
    namespace detail {
    template<class>
    constexpr bool is_reference_wrapper_v = false;
    template<class U>
    constexpr bool is_reference_wrapper_v<std::reference_wrapper<U>> = true;

    template<class C, class Pointed, class T1, class... Args>
    constexpr decltype(auto) invoke_memptr(Pointed C::* f, T1&& t1, Args&&... args)
    {
        if constexpr (std::is_function_v<Pointed>) {
            if constexpr (std::is_base_of_v<C, 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_object_v<Pointed> && sizeof...(args) == 0);
            if constexpr (std::is_base_of_v<C, 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;
        }
    }
    } // namespace detail

    template<class F, class... Args>
    constexpr std::invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)
        noexcept(std::is_nothrow_invocable_v<F, Args...>)
    {
        if constexpr (std::is_member_pointer_v<std::decay_t<F>>)
            return detail::invoke_memptr(f, std::forward<Args>(args)...);
        else
            return std::forward<F>(f)(std::forward<Args>(args)...);
    }
版本二
    template<class R, class F, class... Args>
        requires std::is_invocable_r_v<R, F, Args...>
    constexpr R invoke_r(F&& f, Args&&... args)
        noexcept(std::is_nothrow_invocable_r_v<R, F, Args...>)
    {
        if constexpr (std::is_void_v<R>)
            std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
        else
            return std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
    }

### 示例

    #include <functional>
    #include <iostream>
    #include <type_traits>

    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()
    {
        // 调用自由函数
        std::invoke(print_num, -9);

        // 调用 lambda
        std::invoke([]() { print_num(42); });

        // 调用成员函数
        const Foo foo(314159);
        std::invoke(&Foo::print_add, foo, 1);

        // 调用（访问）数据成员
        std::cout << "num_: " << std::invoke(&Foo::num_, foo) << '\n';

        // 调用函数对象
        std::invoke(PrintNum(), 18);

    #   if defined(__cpp_lib_invoke_r)
        auto add = [](int x, int y) { return x + y; };
        auto ret = std::invoke_r<float>(add, 11, 22);
        static_assert(std::is_same<decltype(ret), float>());
        std::cout << ret << '\n';
        std::invoke_r<void>(print_num, 44);
    #   endif
    }

可能的输出：

    -9
    42
    314160
    num_: 314159
    18
    33
    44

### 参阅

mem_fn (C++11) | 从成员指针创建出函数对象 (函数模板)
result_of invoke_result (C++11)(C++20 中移除)(C++17) | 推导以一组实参调用一个可调用对象的结果类型 (类模板)
is_invocable is_invocable_r is_nothrow_invocable is_nothrow_invocable_r (C++17) | 检查类型能否以给定的实参类型调用（如同以 std::invoke） (类模板)
apply (C++17) | 以一个实参的元组来调用函数 (函数模板)