std::invoke

< cpp‎ | utility‎ | functional
 
 
工具库
通用工具
日期和时间
函数对象
格式化库 (C++20)
(C++11)
关系运算符 (C++20 中弃用)
整数比较函数
(C++20)
swap 与类型运算
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
常用词汇类型
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)

初等字符串转换
(C++17)
(C++17)
 
函数对象
函数包装
(C++11)
(C++11)
部分函数应用
(C++11)
(C++20)
函数调用
invoke
(C++17)
恒等函数对象
(C++20)
引用包装
(C++11)(C++11)
运算符包装
取反器
(C++17)
搜索器
有制约的比较器
旧绑定器与适配器
(C++17 前)
(C++17 前)
(C++17 前)
(C++17 前)
(C++17 前)(C++17 前)(C++17 前)(C++17 前)
(C++20 前)
(C++20 前)
(C++17 前)(C++17 前)
(C++17 前)(C++17 前)

(C++17 前)
(C++17 前)(C++17 前)(C++17 前)(C++17 前)
(C++20 前)
(C++20 前)
 
定义于头文件 <functional>
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 起)

以参数 f 调用可调用 (Callable) 对象。如同以 INVOKE(std::forward<F>(f), std::forward<Args>(args)...)

其中 INVOKE(f, t1, t2, ..., tN) 定义如下:

  • std::is_base_of<T, std::decay_t<decltype(t1)>>::valuetrue ,则 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).

参数

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

异常

noexcept 规定:  
noexcept(std::is_nothrow_invocable_v<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 T, class Type, class T1, class... Args>
constexpr 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>
constexpr 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)...);
}

示例

#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()
{
    // 调用自由函数
    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);
}

输出:

-9
42
314160
num_: 314159
18

参阅

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