std::invoke
什么是 std::invoke
std::invoke 是 C++17 在 <functional> 头文件中引入的一个统一调用工具函数。它可以用相同的语法调用任何"可调用对象":普通函数、函数指针、lambda、仿函数(重载了 operator() 的对象)、成员函数指针、甚至数据成员指针。
为什么需要它?因为 C++ 中不同类型的可调用对象有不同的调用语法:
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 语义。
头文件与签名
#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),后面的是成员函数的参数。
基本示例
#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;
}进阶用法
#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.*m | invoke(m, obj) |
| 数据成员(指针) | ptr->*m | invoke(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) |
|---|---|---|---|
| GCC | 7.0 | 10.0 | 12.0 |
| Clang | 3.9 | 10.0 | 14.0 |
| MSVC | 19.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 是不可或缺的基础设施。