Cpp Callable Objects
在 C++ 中，Callable Object（可调用对象） 指的是任何可以像函数一样被调用的事物。简单来说，就是任何可以使用 () 运算符（Function Call Operator）的对象。
在现代 C++（C++11 及以后）中，可调用对象的概念非常重要，因为它是 STL 算法、线程（std::thread）以及回调机制的核心。
C++ 中的可调用对象主要分为以下 5 类。
1. 普通函数与函数指针 (Function Pointers)
这是最基础的形式，继承自 C 语言。
- 特点： 没有状态（Stateless），行为固定。
- 适用场景： 简单的回调，也就是所谓的 C 风格 API。
#include <iostream>
void hello() {
std::cout << "Hello from Function Pointer!" << std::endl;
}
int main() {
// 定义函数指针
void (*funcPtr)() = &hello; // & 是可选的
// 调用
funcPtr();
return 0;
}
2. 仿函数 (Functors / Function Objects)
仿函数是 C++ 面向对象特性的体现。它是重载了 operator() 的类对象。
特点：
它可以拥有状态 (State)：这是它比函数指针强大的核心原因。你可以通过成员变量保存数据。
内联优化：编译器很容易将仿函数的调用内联（Inline），通常比函数指针更快。
适用场景： 需要在多次调用之间保持状态，或者需要高度优化的 STL 算法（如
std::sort）。
#include <iostream>
class Adder {
int distinct_val; // 内部状态
public:
Adder(int v) : distinct_val(v) {}
// 重载 () 运算符
int operator()(int x) const {
return x + distinct_val;
}
};
int main() {
Adder add10(10); // 创建一个“加10”的加法器
std::cout << add10(5) << std::endl; // 输出 15
return 0;
}
3. Lambda 表达式 (Lambda Expressions)
引入于 C++11，Lambda 是现代 C++ 最常用的可调用对象。
- 本质： Lambda 实际上是匿名仿函数的语法糖。编译器在幕后为你生成了一个重载了
operator()的类。 - 特点： 代码紧凑，可以直接在调用点定义。
- 捕获列表
[]： 允许你捕获上下文中的变量（按值或按引用），这对应仿函数的成员变量。
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
int factor = 2;
std::vector<int> nums = {1, 2, 3};
// [factor] 是捕获列表，捕获外部变量
std::for_each(nums.begin(), nums.end(), [factor](int n) {
std::cout << n * factor << " ";
});
// 输出: 2 4 6
return 0;
}
4. std::function (通用多态包装器)
std::function 是 C++11 引入的一个标准库模板类，位于 <functional> 头文件。
- 特点： 它是一个类型擦除（Type Erasure）的容器。它可以存储任何符合特定签名的可调用对象（函数指针、仿函数、Lambda 等）。
- 代价： 由于使用了虚函数机制和可能的堆内存分配，它比直接使用 Lambda 或模板有轻微的性能开销。
- 适用场景： 当你需要存储不同类型的回调，或者作为函数参数不需要模板化时。
#include <iostream>
#include <functional>
int add(int a, int b) { return a + b; }
int main() {
// 1. 包装普通函数
std::function<int(int, int)> func = add;
// 2. 包装 Lambda
func = [](int a, int b) { return a * b; };
// 3. 包装仿函数
struct Divisor { int operator()(int a, int b) { return a / b; } };
func = Divisor();
std::cout << func(10, 2) << std::endl; // 调用的是最后赋值的 Divisor，输出 5
return 0;
}
5. 类的成员函数指针 (Pointers to Member Functions)
这是一个比较特殊且语法晦涩的类别。非静态成员函数需要依赖一个对象实例才能调用。
- 难点： 不能直接像
f()那样调用，通常需要(obj.*ptr)(args)或(objptr->*ptr)(args)。 - 现代解法： 使用
std::mem_fn或std::bind（虽已过时），或者在 C++17 中使用std::invoke。
#include <iostream>
#include <functional>
class Foo {
public:
void print(int x) { std::cout << "Foo: " << x << std::endl; }
};
int main() {
Foo obj;
// 定义成员函数指针
void (Foo::*ptr)(int) = &Foo::print;
// 传统调用方式 (非常丑陋)
(obj.*ptr)(42);
// 现代方式：使用 std::mem_fn
auto runnable = std::mem_fn(&Foo::print);
runnable(obj, 42); // 第一个参数必须是对象实例
return 0;
}
总结与对比
为了让你更直观地理解，我做了一个对比表：
| 类型 | 是否有状态 | 灵活性 | 性能 | 典型用途 |
|---|---|---|---|---|
| 函数指针 | 无 | 低 | 高 (但在内联方面不如仿函数) | C 接口兼容，简单的全局回调 |
| 仿函数 | 有 | 中 | 极高 (易被编译器内联) | 需要状态的复杂逻辑，STL 算法 |
| Lambda | 有 (通过捕获) | 高 | 极高 (同仿函数) | 绝大多数现代 C++ 场景，局部逻辑 |
| std::function | 有 | 极高 (可存任何类型) | 中 (虚函数开销，堆分配) | API 接口设计，存储异构回调列表 |
| 成员函数指针 | 依赖对象 | 低 | 高 | 特定类操作，通常配合 bind/mem_fn 使用 |
特别提及：std::invoke (C++17)
由于上面提到的调用方式五花八门（有的直接用 ()，有的要用 .*），C++17 引入了 std::invoke 来统一所有可调用对象的调用语法。
1. 统一调用语法
std::invoke 的强大之处在于它抹平了普通函数、Lambda、成员函数甚至成员变量之间的调用差异。
#include <iostream>
#include <functional> // std::invoke 所在头文件
struct MyStruct {
int value{42};
void printSum(int n) const {
std::println("Sum: {}", value + n);
}
};
void plainFunction(int n) {
std::println("Plain: {}", n);
}
int main() {
MyStruct obj;
// 1. 调用普通函数
std::invoke(plainFunction, 10);
// 2. 调用 Lambda
auto lambda = [](int n) { std::println("Lambda: {}", n); };
std::invoke(lambda, 20);
// 3. 调用成员函数 (第一个参数是对象引用或指针)
std::invoke(&MyStruct::printSum, obj, 30);
// 4. 访问成员变量 (没错，成员变量也被视为“可调用”的，返回其值)
std::println("Member value: {}", std::invoke(&MyStruct::value, obj));
return 0;
}2. 为什么需要它？（泛型编程的神器）
如果你在编写一个模板函数，需要接受一个“可调用对象”并执行它，在没有 std::invoke 之前，你很难处理成员函数指针。
坏品味的代码 (C++11 以前)：
template <typename F, typename... Args>
void callIt(F f, Args&&... args) {
// 如果 f 是成员函数指针，这里会编译报错！
// 你必须写一堆 std::enable_if 或重载来区分情况
f(std::forward<Args>(args)...);
}好品味的代码 (使用 std::invoke)：
template <typename F, typename... Args>
auto callIt(F&& f, Args&&... args) {
// 无论 f 是什么，一把梭，全部搞定
return std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
}在现代 C++ 的库开发中，std::invoke 是实现高阶函数（如 std::thread 的构造函数、std::async 等）的基石。它让代码更简洁，消除了不必要的特殊情况处理。
Related Articles
2025-09-23
Cpp Asio
Asio 是一个跨平台的 C++ 库，用于网络和低级 I/O 编程，提供了一套异步操作的框架。Boost.Asio 是其最知名的版本，但独立（standalone）版本的 Asio 允许在不依赖 Boost 的情况下使用。 1. Asio 库概述 Standalone Asio 是一个轻量级的网络编程库，设计目标是提供高效、异步的 I/O 操作。它支持以下功能： 网络编程：TCP、UDP、ICMP 等协议的客户端和服务器开发。 异步 I/O：通过回调、协程（C++20 起支持）或 Future/Promise 模型处理异步操作。 跨平台：支持 Windows、Linux、macOS 等操作系统。 低级 I/O：文件操作、串口通信、定时器等。 与 Boost.Asio 相比，standalone Asio 不依赖 Boost 的其他组件（如 Boost.System），因此更轻量，适合需要减少依赖的场景。 2. 安装与配置 下载 Standalone Asio 可从 GitHub 或其官方网站（think-async.com）获取最新版本。下载后，解压到项目目录。 配置 头文...
2025-12-03
C++ namespace
C++ 命名空间（Namespace）详解 C++命名空间是语言的核心特性之一，用于解决名字冲突问题，尤其在大项目或使用多个库时。基于最新C++23标准，命名空间用法稳定，但结合模块（modules）使用更高效。下面直击要害，逐一拆解，包括[inline namespace]、匿名命名空间和命名空间别名。 参考：[cppreference.com] 1. 基本用法：声明与定义 命名空间通过namespace关键字声明，内容可以分散在多个文件中定义（如同函数定义）。 namespace MyLib { int add(int a, int b) { return a + b; } class Widget { public: void use(); }; } 使用方式： 限定名：MyLib::add(1, 2); 最安全，避免污染全局。 using声明：using MyLib::add; 只引入add，作用域内可用add(1,2)。 using指令：using ...
2025-08-17
C++ Const Pointer
在 C/C++ 中，const 关键字与指针结合使用时，会产生不同的效果，主要是 const 指针 和 指向 const 的指针 两种情况。这两者在语法、含义和使用场景上有着明显的区别。以下是对这两种指针的详细讲解： 1. 指向 const 的指针 定义：指向 const 对象的指针，表示指针指向的内存中的数据是只读的（不能通过该指针修改）。但指针本身的值（即指向的地址）是可以改变的。 语法： const T *ptr; // 或 T const *ptr; T 是数据类型（如 int, char 等）。 const 修饰的是 *ptr，表示指针指向的内容是常量。 这种指针可以指向任何 T 类型的数据（包括非 const 数据），但通过该指针无法修改指向的数据。 特点： 不能通过指针修改指向的数据：*ptr = value 会导致编译错误。 指针本身可以改变：可以让 ptr 指向其他地址。 可以指向非 const 数据：即使指向非 const 数据，也只能以只读方式访问。 示例代码： #include <stdio.h> int main() { ...
2023-06-21
Cpp lambda and bind
基本表达式 [capture](parameters) -> return-type {body} 当没有返回类型时, 可以省略 -> return-type 变量捕获与lambda闭包实现 [] 不截取任何变量 [&] 截取外部作用域中所有变量，并作为引用在函数体中使用 [=] 截取外部作用域中所有变量，并拷贝一份在函数体中使用 [=, &foo] 截取外部作用域中所有变量，并拷贝一份在函数体中使用，但是对foo变量使用引用 [bar] 截取bar变量并且拷贝一份在函数体中使用，同时不截取其他变量 [x, &y] x按值传递，y按引用传递 [this] 截取当前类中的this指针。如果已经使用了&或者=就默认添加此选项。 lambda 的底层实现 lambda 其实是c++的语法糖，是通过c++编译器生成class来实现的，看一个简单的例子。 #include <functional> using namespace std; int main(int argc, char* argv[]) { ...
2023-06-26
C++ 类型擦除详解
C++ 类型擦除详解 类型擦除让 C++ 处理运行时未知类型。核心：隐藏具体类型，只暴露接口。标准库如 std::function, std::any, std::variant 都依赖它。 基于 C++11+，重点 C++17/20 改进。直奔主题：概念、原理、标准实现、手动示例、优缺点。 1. 类型擦除是什么？为什么用？ 定义：运行时统一处理多种类型，编译时忘掉具体类型。只剩接口。 痛点解决： 模板太静态，无法动态类型（如插件、网络数据）。 容器存异构类型：用 Any 包装。 API 解耦：接受任意 callable，不限 lambda/functor。 不是语法，是模式：动态多态 + vtable。 2. 实现原理 三件套： 接口：纯虚基类（clone, destroy, type）。 Holder：模板派生，持值，实现虚函数。 包装器：持 Base*，转发调用。 流程： 存 T val → 创建 Holder<T>。 unique_ptr<Base> 指向它 → 类型擦除。 调用 → vtable 分发。 优化：小对象优化（SBO），栈...
2025-11-04
C++ std::print
概述 C++23 引入了 std::print 和 std::println，这是现代 C++ 对格式化输出的重大改进。相比传统的 printf，这些新函数提供了类型安全、性能优异且易于使用的格式化输出方案。 基本用法 简单输出 #include <print> int main() { // 基本输出 std::print("Hello, World!\n"); // 带换行的输出 std::println("Hello, World!"); return 0; } 格式化输出 #include <print> #include <string> int main() { int age = 25; std::string name = "Alice"; // 格式化输出 std::print("Name: {}, Age: {}\n", name, age); // ...
