命名空间
变体
操作

std::invoke, std::invoke_r

来自 cppreference.com
< cpp‎ | utility‎ | functional
 
 
实用程序库
语言支持
类型支持 (基本类型,RTTI)
库特性测试宏 (C++20)
动态内存管理
程序实用程序
协程支持 (C++20)
可变参数函数
调试支持
(C++26)
三路比较
(C++20)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
通用实用程序
日期和时间
函数对象
格式化库 (C++20)
(C++11)
关系运算符 (C++20 中已弃用)
整数比较函数
(C++20)(C++20)(C++20)   
(C++20)
交换类型操作
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
通用词汇类型
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
基本字符串转换
(C++17)
(C++17)

 
函数对象
函数调用
invokeinvoke_r
(C++17)(C++23)
身份函数对象
(C++20)
透明运算符包装器
(C++14)
(C++14)
(C++14)
(C++14)  
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)

旧的绑定器和适配器
(直到 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 */);
(1) (自 C++17 起)
(自 C++20 起为 constexpr)
template< class R, class F, class... Args >

constexpr R

    invoke_r( F&& f, Args&&... args ) noexcept(/* see below */);
(2) (自 C++23 起)
1) 使用参数 args 调用 可调用 对象 f,如同使用 INVOKE(std::forward<F>(f), std::forward<Args>(args)...). 只有当 std::is_invocable_v<F, Args...>true 时,此重载才参与重载解析。
2) 使用参数 args 调用 可调用 对象 f,如同使用 INVOKE<R>(std::forward<F>(f), std::forward<Args>(args)...). 只有当 std::is_invocable_r_v<R, F, Args...>true 时,此重载才参与重载解析。

内容

[编辑] 参数

f - 可调用 对象,要被调用
args - 传递给 f 的参数

[编辑] 返回值

1) f 返回的值。
2) 如果 R 不是(可能是 cv 限定 的)void,则由 f 返回的值隐式转换为 R。否则为无。

[edit] 异常

1)
noexcept 规范:  
noexcept(std::is_nothrow_invocable_v<F, Args...>)
2)
noexcept 规范:  
noexcept(std::is_nothrow_invocable_r_v<R, F, Args...>)

[edit] 可能的实现

invoke (1)
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>
    using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
 
    template<class C, class Pointed, class Object, class... Args>
    constexpr decltype(auto) invoke_memptr(Pointed C::* member, Object&& object,
                                           Args&&... args)
    {
        using object_t = remove_cvref_t<Object>;
        constexpr bool is_member_function = std::is_function_v<Pointed>;
        constexpr bool is_wrapped = is_reference_wrapper_v<object_t>;
        constexpr bool is_derived_object = std::is_same_v<C, object_t>
                                        || std::is_base_of_v<C, object_t>;
 
        if constexpr (is_member_function)
        {
            if constexpr (is_derived_object)
                return (std::forward<Object>(object) .* member)
                           (std::forward<Args>(args)...);
            else if constexpr (is_wrapped)
                return (object.get() .* member)(std::forward<Args>(args)...);
            else
                return ((*std::forward<Object>(object)) .* member)
                           (std::forward<Args>(args)...);
        }
        else
        {
            static_assert(std::is_object_v<Pointed> && sizeof...(args) == 0);
            if constexpr (is_derived_object)
                return std::forward<Object>(object) .* member;
            else if constexpr (is_wrapped)
                return object.get() .* member;
            else
                return (*std::forward<Object>(object)) .* member;
        }
    }
} // 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<detail::remove_cvref_t<F>>)
        return detail::invoke_memptr(f, std::forward<Args>(args)...);
    else
        return std::forward<F>(f)(std::forward<Args>(args)...);
}
invoke_r (2)
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)...);
}

[edit] 备注

特性测试 Std 特性
__cpp_lib_invoke 201411L (C++17) std::invoke, (1)
__cpp_lib_invoke_r 202106L (C++23) std::invoke_r, (2)

[edit] 示例

#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::cout << "invoke a free function: ";
    std::invoke(print_num, -9);
 
    std::cout << "invoke a lambda: ";
    std::invoke([](){ print_num(42); });
 
    std::cout << "invoke a member function: ";
    const Foo foo(314159);
    std::invoke(&Foo::print_add, foo, 1);
 
    std::cout << "invoke (i.e., access) a data member num_: "
              << std::invoke(&Foo::num_, foo) << '\n';
 
    std::cout << "invoke a function object: ";
    std::invoke(PrintNum(), 18);
 
#if defined(__cpp_lib_invoke_r)
    auto add = [](int x, int y){ return x + y; };
    std::cout << "invoke a lambda converting result to float: ";
    auto ret = std::invoke_r<float>(add, 11, 22);
    static_assert(std::is_same<decltype(ret), float>());
    std::cout << std::fixed << ret << "\ninvoke print_num: ";
    std::invoke_r<void>(print_num, 44);
#endif
}

可能的输出

invoke a free function: -9
invoke a lambda: 42
invoke a member function: 314160
invoke (i.e., access) a data member num_: 314159
invoke a function object: 18
invoke a lambda converting result to float: 33.000000
invoke print_num: 44

[edit] 参见

(C++11)
将指向成员的指针转换为函数对象
(函数模板) [edit]
(C++11)(在 C++20 中删除)(C++17)
推断使用一组参数调用可调用对象的结果类型
(类模板) [edit]
检查类型是否可以被调用(如同通过 std::invoke)并使用给定的参数类型
(类模板) [edit]
(C++17)
使用元组参数调用函数
(函数模板) [edit]