std::invoke, std::invoke_r
来自cppreference.com
< cpp | utility | functional
| 在标头 <functional> 定义
|
||
| (1) | ||
| template< class F, class... Args > std::invoke_result_t<F, Args...> |
(C++17 起) (C++20 前) |
|
| template< class F, class... Args > constexpr std::invoke_result_t<F, Args...> |
(C++20 起) | |
| template< class R, class F, class... Args > constexpr R invoke_r(F&& f, Args&&... args) noexcept(/* 见下文 */); |
(2) | (C++23 起) |
1) 以参数 args 调用可调用 (Callable) 对象 f，效果如同
INVOKE(std::forward<F>(f), std::forward<Args>(args)...)。此重载只有在 std::is_invocable_v<F, Args...> 是 true时才会参与重载决议。2) 以参数 args 调用可调用 (Callable) 对象 f，效果如同
INVOKE<R>(std::forward<F>(f), std::forward<Args>(args)...)。此重载只有在 std::is_invocable_r_v<R, F, Args...> 是 true时才会参与重载决议。参数
| f | - | 要调用的可调用 (Callable) 对象 |
| args | - | 传递给 f 的参数 |
返回值
1) f 返回的值。
2)
R 是 void 时不返回，否则返回 隐式转换到 R 的 f 的返回值。异常
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)...); } |
注解
| 功能特性测试宏 | 值 | 标准 | 注释 |
|---|---|---|---|
__cpp_lib_invoke |
201411L | (C++17) | std::invoke
|
__cpp_lib_invoke_r |
202106L | (C++23) | std::invoke_r
|
示例
运行此代码
#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
参阅
| (C++11) |
从成员指针创建出函数对象 (函数模板) |
| (C++11)(C++20 中移除)(C++17) |
推导以一组实参调用一个可调用对象的结果类型 (类模板) |
| 检查类型能否以给定的实参类型调用（如同以 std::invoke） (类模板) | |
| (C++17) |
以一个实参的元组来调用函数 (函数模板) |