std::invoke, std::invoke_r

 

C++

语言

标准库头文件

自立与有宿主实现

具名要求

语言支持库

概念库 (C++20)

诊断库

工具库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

原子操作库 (C++11)

线程支持库 (C++11)

技术规范

 

工具库

语言支持 类型支持（基本类型、 RTTI 、类型特征）     库功能特性测试宏 (C++20) 动态内存管理 程序工具 错误处理 协程支持 (C++20) 变参数函数 launder (C++17) initializer_list (C++11) source_location (C++20) 三路比较 (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20) is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

通用工具 日期和时间 函数对象 bitset 格式化库 (C++20) hash (C++11) integer_sequence (C++14) 关系运算符 (C++20 中弃用) rel_ops::operator!=rel_ops::operator> rel_ops::operator<=rel_ops::operator>= 整数比较函数 cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20) cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) swap 与类型运算 swap ranges::swap (C++20) exchange (C++14) declval (C++11) forward (C++11) move (C++11) move_if_noexcept (C++11) as_const (C++17) to_underlying (C++23) 常用词汇类型 pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) 初等字符串转换 to_chars (C++17) from_chars (C++17) chars_format (C++17) 栈踪 stacktrace_entry (C++23) basic_stacktrace (C++23)

 

函数对象

函数包装 function (C++11) move_only_function (C++23) mem_fn (C++11) bad_function_call (C++11)	部分函数应用 bind (C++11) bind_front (C++20) is_bind_expression (C++11) is_placeholder (C++11) _1, _2, _3, ... (C++11)
函数调用 invokeinvoke_r (C++17)(C++23) 恒等函数对象 identity (C++20)	引用包装 reference_wrapper (C++11) refcref (C++11)(C++11) unwrap_referenceunwrap_ref_decay (C++20)(C++20)
运算符包装 plus minus negate multiplies divides modulus bit_and bit_or bit_not (C++14) bit_xor equal_to not_equal_to greater less greater_equal less_equal logical_and logical_or logical_not	通透运算符包装 plus<> (C++14) minus<> (C++14) negate<> (C++14) multiplies<> (C++14) divides<> (C++14) modulus<> (C++14) bit_and<> (C++14) bit_or<> (C++14) bit_not<> (C++14) bit_xor<> (C++14) equal_to<> (C++14) not_equal_to<> (C++14) greater<> (C++14) less<> (C++14) greater_equal<> (C++14) less_equal<> (C++14) logical_and<> (C++14) logical_or<> (C++14) logical_not<> (C++14)
取反器 not_fn (C++17) 搜索器 default_searcher (C++17) boyer_moore_searcher (C++17) boyer_moore_horspool_searcher (C++17)	受约束的比较器 ranges::equal_to (C++20) ranges::not_equal_to (C++20) ranges::greater (C++20) ranges::less (C++20) ranges::greater_equal (C++20) ranges::less_equal (C++20) compare_three_way (C++20)
旧绑定器与适配器
unary_function (C++17 前) binary_function (C++17 前) ptr_fun (C++17 前) pointer_to_unary_function (C++17 前) pointer_to_binary_function (C++17 前) mem_fun (C++17 前) mem_fun_tmem_fun1_tconst_mem_fun_tconst_mem_fun1_t (C++17 前)(C++17 前)(C++17 前)(C++17 前) not1 (C++20 前) not2 (C++20 前)	binder1stbinder2nd (C++17 前)(C++17 前) bind1stbind2nd (C++17 前)(C++17 前) mem_fun_ref (C++17 前) mem_fun_ref_tmem_fun1_ref_tconst_mem_fun_ref_tconst_mem_fun1_ref_t (C++17 前)(C++17 前)(C++17 前)(C++17 前) unary_negate (C++20 前) binary_negate (C++20 前)

 

定义于头文件 <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_ofinvoke_result (C++11)(C++20 中移除)(C++17)	推导以一组实参调用一个可调用对象的结果类型 (类模板)
is_invocableis_invocable_ris_nothrow_invocableis_nothrow_invocable_r (C++17)	检查类型能否以给定的实参类型调用（如同以 std::invoke） (类模板)
apply (C++17)	以一个实参的元组来调用函数 (函数模板)