std::invoke ​

什么是 std::invoke ​

std::invoke 是 C++17 在 <functional> 头文件中引入的一个统一调用工具函数。它可以用相同的语法调用任何"可调用对象":普通函数、函数指针、lambda、仿函数(重载了 operator() 的对象)、成员函数指针、甚至数据成员指针。

为什么需要它?因为 C++ 中不同类型的可调用对象有不同的调用语法:

cpp
func(args);                    // 普通函数、lambda、仿函数
(obj.*member_func)(args);      // 成员函数指针(通过对象)
(ptr->*member_func)(args);     // 成员函数指针(通过指针)
obj.*data_member;              // 数据成员指针(通过对象)
ptr->*data_member;             // 数据成员指针(通过指针)

std::invoke 把这些不同的语法统一成一种形式:std::invoke(callable, args...)。这在编写泛型代码(模板库、回调系统等)时特别有用——你不需要关心传进来的可调用对象具体是什么类型,统一用 invoke 调用就行。

C++ 标准内部定义了一个名为 INVOKE 的伪操作来描述这种统一调用语义,std::invoke 就是 INVOKE 的直接暴露。很多标准库组件(std::function、std::bind、std::thread、std::async、std::apply 等)内部都使用 INVOKE 语义。

头文件与签名 ​

cpp
#include <functional>

// C++17
template<class F, class... Args>
std::invoke_result_t<F, Args...> invoke(F&& f, Args&&... args);

// C++20 起变为 constexpr
// C++23 新增 invoke_r(指定返回类型)
template<class R, class F, class... Args>
constexpr R invoke_r(F&& f, Args&&... args);

调用规则 ​

std::invoke(f, args...) 的行为取决于 f 的类型:

f 的类型调用方式等价表达式
普通函数/函数指针直接调用f(args...)
lambda 表达式直接调用f(args...)
仿函数(有 operator())直接调用f(args...)
成员函数指针 + 对象/引用通过对象调用(obj.*f)(rest_args...)
成员函数指针 + 指针通过指针调用(ptr->*f)(rest_args...)
数据成员指针 + 对象/引用访问成员obj.*f
数据成员指针 + 指针访问成员ptr->*f

对于成员指针,args 的第一个参数是对象实例(或指针、reference_wrapper),后面的是成员函数的参数。

基本示例 ​

cpp
#include <iostream>
#include <functional>
#include <string>
#include <memory>

// ============================
// 示例1:调用普通函数
// ============================

int add(int a, int b) {
    return a + b;
}

void free_function_demo() {
    // 通过函数指针调用
    int result = std::invoke(add, 3, 4);
    std::cout << "add(3, 4) = " << result << std::endl;  // 7

    // 也可以传函数指针变量
    int (*fptr)(int, int) = add;
    std::cout << "fptr(5, 6) = " << std::invoke(fptr, 5, 6) << std::endl;  // 11
}

// ============================
// 示例2:调用 lambda
// ============================

void lambda_demo() {
    auto multiply = [](int a, int b) { return a * b; };
    std::cout << "multiply(3, 7) = " << std::invoke(multiply, 3, 7) << std::endl;  // 21

    // 带捕获的 lambda
    int base = 100;
    auto add_base = [&base](int x) { return base + x; };
    std::cout << "add_base(42) = " << std::invoke(add_base, 42) << std::endl;  // 142

    // 无参数 lambda
    auto hello = []() { std::cout << "hello from lambda" << std::endl; };
    std::invoke(hello);
}

// ============================
// 示例3:调用仿函数
// ============================

struct Multiplier {
    int factor;
    int operator()(int x) const {
        return x * factor;
    }
};

void functor_demo() {
    Multiplier m{10};
    std::cout << "Multiplier(10)(7) = " << std::invoke(m, 7) << std::endl;  // 70
}

// ============================
// 示例4:调用成员函数
// ============================

struct Person {
    std::string name;
    int age;

    void greet() const {
        std::cout << "你好,我是 " << name << std::endl;
    }

    std::string info(const std::string& title) const {
        return title + ": " + name + ", " + std::to_string(age) + " 岁";
    }
};

void member_function_demo() {
    Person p{"张三", 30};

    // 通过对象调用成员函数
    std::invoke(&Person::greet, p);

    // 带参数的成员函数
    std::string info = std::invoke(&Person::info, p, std::string("个人信息"));
    std::cout << info << std::endl;

    // 通过指针调用
    Person* ptr = &p;
    std::invoke(&Person::greet, ptr);

    // 通过智能指针调用
    auto sp = std::make_shared<Person>(Person{"李四", 25});
    std::invoke(&Person::greet, sp);

    // 通过 reference_wrapper 调用
    std::invoke(&Person::greet, std::ref(p));
}

// ============================
// 示例5:访问数据成员
// ============================

void data_member_demo() {
    Person p{"王五", 28};

    // 通过数据成员指针访问
    std::string name = std::invoke(&Person::name, p);
    int age = std::invoke(&Person::age, p);

    std::cout << "姓名: " << name << ", 年龄: " << age << std::endl;

    // 通过指针访问
    Person* ptr = &p;
    std::cout << "指针访问: " << std::invoke(&Person::name, ptr) << std::endl;
}

int main() {
    std::cout << "=== 普通函数 ===" << std::endl;
    free_function_demo();

    std::cout << "\n=== lambda ===" << std::endl;
    lambda_demo();

    std::cout << "\n=== 仿函数 ===" << std::endl;
    functor_demo();

    std::cout << "\n=== 成员函数 ===" << std::endl;
    member_function_demo();

    std::cout << "\n=== 数据成员 ===" << std::endl;
    data_member_demo();

    return 0;
}

进阶用法 ​

cpp
#include <iostream>
#include <functional>
#include <string>
#include <vector>
#include <type_traits>

// ============================
// 进阶1:泛型回调执行器
// ============================

// 不关心 callable 是函数、lambda、成员函数还是仿函数
// 统一用 invoke 调用
template<typename Callable, typename... Args>
decltype(auto) execute(Callable&& f, Args&&... args) {
    // 打印调用前的日志
    std::cout << "[execute] 调用中..." << std::endl;

    // 统一调用
    if constexpr (std::is_void_v<std::invoke_result_t<Callable, Args...>>) {
        std::invoke(std::forward<Callable>(f), std::forward<Args>(args)...);
        std::cout << "[execute] 完成(void)" << std::endl;
    } else {
        auto result = std::invoke(std::forward<Callable>(f), std::forward<Args>(args)...);
        std::cout << "[execute] 完成,结果: " << result << std::endl;
        return result;
    }
}

// ============================
// 进阶2:配合 is_invocable 做编译期检查
// ============================

template<typename F, typename... Args>
void safe_call(F&& f, Args&&... args) {
    // 编译期检查是否可调用
    if constexpr (std::is_invocable_v<F, Args...>) {
        std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
    } else {
        std::cout << "不可调用!参数类型不匹配" << std::endl;
    }
}

// ============================
// 进阶3:对容器中的每个元素调用成员函数
// ============================

struct Task {
    std::string name;
    void run() const {
        std::cout << "运行任务: " << name << std::endl;
    }
    int priority() const {
        return static_cast<int>(name.size());
    }
};

template<typename Container, typename MemPtr>
void for_each_invoke(const Container& c, MemPtr mp) {
    for (const auto& item : c) {
        std::invoke(mp, item);
    }
}

// 提取成员值到 vector
template<typename Container, typename MemPtr>
auto extract(const Container& c, MemPtr mp) {
    using ResultType = std::invoke_result_t<MemPtr, typename Container::value_type>;
    std::vector<ResultType> results;
    for (const auto& item : c) {
        results.push_back(std::invoke(mp, item));
    }
    return results;
}

int main() {
    // 泛型执行器
    std::cout << "=== 泛型执行器 ===" << std::endl;
    execute([](int x) { return x * x; }, 7);
    execute([]() { std::cout << "无参数 lambda" << std::endl; });

    struct Calc {
        int compute(int a, int b) const { return a + b; }
    };
    Calc calc;
    execute(&Calc::compute, calc, 10, 20);

    // 对容器调用成员函数
    std::cout << "\n=== 容器成员函数 ===" << std::endl;
    std::vector<Task> tasks{{"编译"}, {"测试"}, {"部署到生产环境"}};
    for_each_invoke(tasks, &Task::run);

    // 提取成员值
    auto priorities = extract(tasks, &Task::priority);
    std::cout << "优先级: ";
    for (auto p : priorities) std::cout << p << " ";
    std::cout << std::endl;

    // 提取数据成员
    auto names = extract(tasks, &Task::name);
    std::cout << "名称: ";
    for (const auto& n : names) std::cout << n << " ";
    std::cout << std::endl;

    return 0;
}

相关类型特征 ​

特征说明
std::is_invocable<F, Args...>检查 F 是否可以用 Args 调用
std::is_invocable_r<R, F, Args...>检查 F 是否可以用 Args 调用且返回值可转为 R
std::is_nothrow_invocable<F, Args...>检查调用是否不抛异常
std::invoke_result_t<F, Args...>获取调用的返回类型

std::invoke 与直接调用的对比 ​

场景直接调用std::invoke
普通函数f(args)invoke(f, args)
成员函数(对象)(obj.*f)(args)invoke(f, obj, args)
成员函数(指针)(ptr->*f)(args)invoke(f, ptr, args)
数据成员(对象)obj.*minvoke(m, obj)
数据成员(指针)ptr->*minvoke(m, ptr)
泛型代码中需要分支处理不同调用语法统一语法

适用场景 ​

  • 编写接受任意可调用对象的泛型函数/模板
  • 回调系统中统一调用不同类型的回调
  • 在模板代码中调用可能是成员函数指针的可调用对象
  • 配合 std::is_invocable 做编译期可调用性检查
  • 标准库内部(std::thread、std::async、std::apply、std::bind 等)的基础设施

常见问题 ​

std::invoke 比直接调用慢吗?

不会。std::invoke 在编译期就确定了调用方式,编译器会完全内联优化。生成的机器码和直接调用没有区别。

std::invoke 和 std::apply 有什么区别?

std::invoke(f, a, b, c) 直接传递各个参数;std::apply(f, tuple) 把 tuple 展开为参数。apply 内部就是用 invoke 实现的。需要解包 tuple 时用 apply,参数已经是独立的就用 invoke。

std::invoke 能调用重载函数吗?

不能直接调用。和 std::apply 一样,重载函数无法作为模板参数推导的对象。用 lambda 包装或 static_cast 指定具体的函数签名。

什么时候应该用 std::invoke 而不是直接调用?

在泛型代码中——当你不知道传进来的可调用对象是普通函数还是成员函数指针时,用 invoke 可以统一处理。在非泛型代码中,直接调用更简洁,没必要用 invoke。

注意事项 ​

  • std::invoke 在 C++17 中不是 constexpr 的,C++20 起才是
  • 调用成员函数指针时,第一个参数必须是对象实例(或指针、reference_wrapper、智能指针)
  • 访问数据成员时不需要额外参数(只需要对象实例)
  • 如果 f 是重载函数或模板函数,需要用 lambda 或 static_cast 消歧义
  • std::invoke_result_t 用来在编译期获取调用结果类型,常配合 if constexpr 使用

编译器支持情况 ​

编译器std::invoke(C++17)constexpr invoke(C++20)std::invoke_r(C++23)
GCC7.010.012.0
Clang3.910.014.0
MSVC19.10 (VS 2017)19.28 (VS 2019 16.8)19.34 (VS 2022 17.4)

总结 ​

std::invoke 是 C++17 提供的统一可调用对象调用工具。它把 C++ 中五六种不同的调用语法(普通函数调用、成员函数指针调用、数据成员指针访问等)统一为 invoke(callable, args...) 一种形式。这在编写泛型模板代码时价值巨大——你的模板函数可以接受任何可调用对象,不需要为成员函数指针写特殊处理。配合 std::is_invocable 和 std::invoke_result_t 等类型特征,可以在编译期检查可调用性和推导返回类型。对于非泛型代码,直接调用更简洁;但在模板库、回调系统、任务队列等需要处理任意可调用对象的场景下,std::invoke 是不可或缺的基础设施。