Chapter 35: Std Function
核心问题与阅读主线
std::function<R(Args...)> 用于把函数指针、捕获 lambda 与函数对象等不同具体类型的可调用目标,存入同一运行时容器或跨模块接口:它在构造时擦除具体类型,对外仅暴露固定调用签名并转发调用。代价是间接派发、内联受阻、目标须可复制,以及大对象可能触发堆分配。
全章共用场景样本
本章以事件分发器(Dispatcher)作为贯穿场景:调用点只依赖固定签名 void(const Event&),注册点则会依次传入函数指针、小捕获 lambda、大捕获 lambda 与带状态对象,借此对照存储结构、分配边界与工程选型。
std::function 于 C++11 引入 <functional>,标准工作草案将其定义为广义函数指针的多态包装器(polymorphic wrapper),可存储、复制并调用兼容目标,且规定空对象调用抛出 std::bad_function_call;标准条款见 C++ working draft 的 std::function 条款 与 cppreference 的 std::function 页面。
35.1 type erasure 与 callable wrapper
type erasure(类型擦除)指包装对象在构造时接收具体类型,随后将其隐藏于内部、对外只暴露固定接口。对 std::function<void(const Event&)> 而言,统一表面就是 operator()(const Event&),具体目标类型仅在构造、复制、销毁和转发调用时由内部入口访问。
在贯穿场景 Dispatcher 中,注册端可以传入不同具体类型的 callable,分发端只按统一签名调用:
#include <functional>
#include <iostream>
#include <string>
#include <vector>
struct Event {
std::string name;
int value{};
};
class Dispatcher {
public:
using Handler = std::function<void(const Event&)>;
void add(Handler handler) {
handlers_.push_back(std::move(handler));
}
void emit(const Event& event) const {
for (const auto& handler : handlers_) {
handler(event);
}
}
private:
std::vector<Handler> handlers_;
};
void print_event(const Event& event) {
std::cout << event.name << ':' << event.value << '\n';
}
int main() {
Dispatcher dispatcher;
int threshold = 10;
dispatcher.add(print_event);
dispatcher.add([threshold](const Event& event) {
if (event.value >= threshold) {
std::cout << "accepted\n";
}
});
dispatcher.emit(Event{"load", 12});
}
Dispatcher::handlers_ 仅声明了单一类型 Handler,却能同时存入函数指针 print_event 和按值捕获 threshold 的匿名闭包。只要目标能以 Args... 调用且返回值可转为 R(R 为 void 时忽略返回值,如 std::function<int(std::string_view)> 要求返回结果可转成 int),即可构造同一 wrapper。
主流标准库实现通常把 std::function 拆成三类状态来承载这一机制:
- 目标存储区:保存具体 callable(内联缓冲区或堆分配指针)。
- invoker(调用入口):把存储区还原为真实目标类型并转发
Args...。 - manager(管理入口):负责目标的复制、移动、析构与 RTTI 类型查询。
边界与误区
manager 的生命周期契约决定了两项约束:其一,普通 std::function 要求目标可复制构造(CopyConstructible),不可复制对象无法装入;其二,默认构造或赋值为 nullptr 会得到空 wrapper,对其直接调用会抛出 std::bad_function_call。
std::function 的类型状态与值状态分离,调用可选回调前应通过 operator bool() 显式判空(必填回调应在构造期校验):
std::function<void(const Event&)> handler;
if (handler) {
handler(Event{"ready", 1});
}
除调用外,std::function 还提供有限的底层访问与外层职责边界:
- 调试与桥接:
target_type()和target<T>()可在调试或对接旧接口时探测底层目标类型,但业务主路径频繁向下还原类型会抵消类型擦除收益。 - 抽象粒度边界:
std::function只抽象“调用一次”,不包含订阅 ID、取消、比较或优先级;这些元数据应放在外层 handler record 中管理。
35.2 small object optimization 与 heap allocation
small object optimization(SOO,小对象优化)指将体积和对齐满足条件的小目标直接构造在 wrapper 局部缓冲区中,以省去堆分配。标准仅将其列为推荐实践,实际内联容量、对齐与移动条件依赖 libstdc++、libc++ 或 MSVC STL 实现,工程上只能视为常见优化而非跨平台保证。
同一签名 std::function<void(const Event&)> 可以装入体积差异很大的目标对象:
#include <array>
#include <functional>
#include <string>
struct Event {
std::string name;
int value{};
};
void print_event(const Event&);
void register_handlers() {
int threshold = 10;
std::array<int, 128> table{};
std::function<void(const Event&)> a = print_event;
std::function<void(const Event&)> b = [threshold](const Event& event) {
if (event.value >= threshold) {
print_event(event);
}
};
std::function<void(const Event&)> c = [table](const Event& event) {
if (event.value < static_cast<int>(table.size())) {
print_event(event);
}
};
}
不同捕获形式决定了内部存储与复制成本的分化:
| 目标形式 | 闭包保存内容 | SOO 命中与堆分配 | 拷贝成本与异常边界 |
|---|---|---|---|
函数指针 / std::reference_wrapper | 单个函数地址或引用包装 | 直接内联,不触发堆分配 | 标准保证拷贝不抛内存分配异常 |
小捕获 lambda(如 b) | 少量标量(如单个 int) | 通常命中内联缓冲区 | 按目标值拷贝;受目标拷贝构造异常影响 |
大捕获 lambda(如 c) | 整个 std::array<int, 128> | 超出内联容量,触发堆分配 | 每次构造与复制都分配并拷贝整块数组 |
共享状态捕获(std::shared_ptr) | 单个控制块智能指针 | 闭包体积固定,常可命中 SOO | 复制增加原子引用计数,调用多一次指针解引用 |
关键事实
std::function 的构造成本分两层:第一层是所有目标共有的类型擦除成本(维护 invoker 与 manager),第二层才是超出 local storage / small buffer 后触发的堆分配与释放成本。SOO 只能消除第二层堆分配,无法消除第一层间接调用;此外,只有函数指针与 std::reference_wrapper 具有标准保证的“拷贝不抛分配异常”语义。
std::function 默认按值持有闭包对象:复制 wrapper 会按目标类型拷贝构造闭包。捕获引用时,闭包保存的只是引用关系而非所有权:
struct State {
int limit{};
};
void setup(Dispatcher& dispatcher, State& state) {
dispatcher.add([&state](const Event& event) {
if (event.value >= state.limit) {
print_event(event);
}
});
}
边界与误区
std::function 只管理闭包对象自身的生存期,不会延长外部被引用对象(如 state)的生命周期。setup 返回后一旦 state 先行销毁,保存在 Dispatcher 中的回调即形成悬垂引用。
若 handler 拷贝频繁、状态对象体积大且生命周期须跨越注册作用域,应将大状态外移至堆上由 std::shared_ptr 托管:
#include <memory>
#include <vector>
struct LookupTable {
std::vector<int> values;
};
void setup_with_shared_table(Dispatcher& dispatcher,
std::shared_ptr<const LookupTable> table) {
dispatcher.add([table = std::move(table)](const Event& event) {
if (event.value < static_cast<int>(table->values.size())) {
print_event(event);
}
});
}
这种写法的收益是闭包体积稳定、易命中 SOO 且避免整表拷贝;代价是拷贝 handler 时产生引用计数原子更新,调用时增加一次指针解引用。
35.3 调用开销与性能边界
模板直接接收 callable 时,编译器在实例化点已知具体类型,常能内联 operator();而 std::function 调用时必须跨过运行时间接边界:
- 间接派发与优化屏障:
handler(event)需先取调用入口,再把目标地址和参数转交invoker,阻断跨调用点的常规内联。 - 空对象检查路径:调用前须检查内部是否为空并保留
std::bad_function_call异常路径。 - 频率分界:UI 事件、任务完成回调、插件通知等低频场景中,该开销常被业务逻辑掩盖;按像素、按元素或按订单触发的热循环中,则会放大为可观测瓶颈。
下面用同一谓词对比模板实例化与类型擦除的优化边界:
#include <functional>
#include <vector>
template <class Predicate>
int count_template(const std::vector<int>& values, Predicate pred) {
int count = 0;
for (int value : values) {
if (pred(value)) {
++count;
}
}
return count;
}
int count_erased(const std::vector<int>& values,
const std::function<bool(int)>& pred) {
int count = 0;
for (int value : values) {
if (pred(value)) {
++count;
}
}
return count;
}
count_template 为每种 Predicate 生成独立特化,循环内 pred(value) 及其捕获状态易于内联和寄存器优化;count_erased 只有一份函数体,减少了二进制代码膨胀,却把循环体内的每次谓词调用置于 invoker 间接入口之后。
性能边界同样体现在批量构造与容器扩容阶段:
void register_many(Dispatcher& dispatcher, int base) {
for (int i = 0; i < 1000; ++i) {
dispatcher.add([base, i](const Event& event) {
if (event.value == base + i) {
print_event(event);
}
});
}
}
尽管 [base, i] 通常可落入 SOO,批量注册与容器动态扩容仍会反复移动或复制 wrapper 并调度 manager。排查时应将“单闭包是否命中 SOO”与“容器是否频繁搬迁”拆开处理,提前调用 handlers_.reserve(n) 并把注册期与热路径隔离。
运行时还需注意三类容易被忽视的性能与语义陷阱:
- 目标多样性与分支预测:同一容器中若混杂大量不同具体类型的 handler,
invoker目标地址分散,CPU 间接分支预测命中率会随目标多样性上升而下降。 - 空调用不可作常规分支:严禁在热路径靠捕获
std::bad_function_call探测空状态;必填回调应在注册期校验,可选回调应显式判断operator bool()。 - 引用返回与临时量绑定:返回引用的
std::function必须避免返回类型推导误配。
#include <functional>
#include <string>
const std::string& global_name() {
static const std::string name = "dispatcher";
return name;
}
std::function<const std::string&()> make_name_reader() {
return []() -> const std::string& {
return global_name();
};
}
边界与误区
若省略 lambda 的尾置返回类型 -> const std::string&,[] { return global_name(); } 会按值推导并返回临时 std::string,装入 std::function<const std::string&()> 后引用将绑定到已销毁临时对象(C++23 起已禁止此类悬垂引用绑定)。工程上返回引用时务必显式写明 -> const T&,并确认被引用对象存活周期覆盖调用结果使用期。
35.4 与模板参数、函数指针和 lambda 的对比
工程选型不应只谈“灵活”或“慢”,而应将四种常见 callable 形态放在存储需求、类型保留与运行成本同一组维度下取舍:
| 形式 | 类型信息 | 状态携带 | 运行时替换 | 典型成本 | 适用场景 |
|---|---|---|---|---|---|
模板参数 F | 调用点保留具体类型 | 支持 | 编译期通过不同实例化表达 | 二进制实例化增多,调用可内联 | 泛型算法、热循环、即时执行策略 |
| 函数指针 | 固定签名与代码地址 | 无(需额外 void* 上下文) | 支持(随时替换函数地址) | 一次间接跳转,无包装成本 | C 接口、无状态回调、稳定 ABI 边界 |
| lambda 具体类型 | 编译器生成唯一闭包类型 | 支持(值/引用捕获) | 同变量类型固定,跨闭包不可混存 | 零擦除成本,易于内联 | 局部算法参数、短生命周期回调 |
std::function | 擦除具体类型,只留签名 | 支持(要求目标可复制) | 支持(统一槽位动态替换) | invoker 间接调用,大对象堆分配 | 回调存储、事件总线、跨模块稳定接口 |
模板参数适合调用点与算法在同一编译上下文内协作,例如 std::sort 或下方 emit_once——Handler 保留闭包类型以便内联,但无法把多种不同具体类型的回调存进同一 std::vector 以延迟触发:
template <class Handler>
void emit_once(const Event& event, Handler handler) {
handler(event);
}
void use_template() {
int threshold = 10;
emit_once(Event{"load", 12}, [threshold](const Event& event) {
if (event.value >= threshold) {
print_event(event);
}
});
}
无状态回调或跨 C ABI 边界时,函数指针模型最简单;一旦需要绑定 threshold 等上下文,C 接口往往演变为函数指针加 void* context,类型安全完全由调用方自负:
using CCallback = void (*)(void* context, const Event& event);
struct CSlot {
void* context{};
CCallback callback{};
};
std::function<void(const Event&)> 将上下文状态封装进目标对象内部,免去了手工 void* 强转,代价则是 wrapper 维护与间接派发成本。至于裸 lambda 具体类型,每个 lambda 表达式都拥有编译器生成的独立匿名类型,适合局部高效传参;一旦要混入同构容器,就必须经过类型擦除。
另一个常被忽视的硬性约束是目标可复制性:
#include <memory>
void move_only_capture() {
auto resource = std::make_unique<int>(42);
auto task = [resource = std::move(resource)](const Event& event) {
if (event.value == *resource) {
print_event(event);
}
};
// std::function<void(const Event&)> handler = std::move(task);
// 普通 std::function 要求目标可复制,捕获 unique_ptr 的闭包无法通过编译。
}
关键事实
std::function 在接口上承诺自身可复制,因此编译期强制要求目标满足 CopyConstructible;捕获 std::unique_ptr 等只移动资源的闭包无法装入普通 std::function。C++23 引入 std::move_only_function 表达只移动回调;C++11 至 C++20 项目若无需复制回调集合,应编写自定义 move-only wrapper 或专用任务句柄,避免为迎合 std::function 强行把独占资源改成 std::shared_ptr。
设计接收 callable 的 API 时,应按“即时消费”还是“延迟保存”划分接口边界:
template <class Handler>
void visit_event_now(const Event& event, Handler&& handler) {
std::forward<Handler>(handler)(event);
}
class EventSource {
public:
void set_handler(std::function<void(const Event&)> handler) {
handler_ = std::move(handler);
}
void notify(const Event& event) const {
if (handler_) {
handler_(event);
}
}
private:
std::function<void(const Event&)> handler_;
};
核心判断
函数只在当前调用栈内消费一次回调(如 visit_event_now),优先用模板 Handler&& 保留具体类型与内联机会;函数需要把回调存入成员或容器以延迟调用(如 EventSource::set_handler),才使用 std::function 把存储语义写进签名。
35.5 工程使用场景
std::function 最契合“注册点决定实现、调用点只关心签名、回调需被长期存储或动态替换”的场景,包括事件总线、任务完成通知、状态机 hook、插件扩展点与异步结果回调。这些路径调用频率有限,接口稳定性和解耦收益高于极端内联。
工程化事件系统通常需要订阅 ID、优先级、名称等元数据。应让外层记录(Subscription)承担管理职责,std::function 只负责“如何调用”:
#include <cstddef>
#include <functional>
#include <string>
#include <vector>
struct Subscription {
std::size_t id{};
int priority{};
std::string name;
std::function<void(const Event&)> handler;
};
class EventBus {
public:
void subscribe(Subscription subscription) {
subscriptions_.push_back(std::move(subscription));
}
void publish(const Event& event) const {
for (const auto& subscription : subscriptions_) {
if (subscription.handler) {
subscription.handler(event);
}
}
}
private:
std::vector<Subscription> subscriptions_;
};
将身份、排序与注销策略留在 Subscription 外层,后续若要将个别热点回调切换为静态组合或把异步任务改成 move-only wrapper,也无需推翻整体模型。
当类成员需要保存外部传入的回调时,参数应按值接收再 std::move 到成员,避免 const std::function<...>& 借用后再拷贝带来的额外复制与所有权模糊:
class Worker {
public:
using Done = std::function<void(int)>;
explicit Worker(Done done)
: done_(std::move(done)) {}
void finish(int code) const {
if (done_) {
done_(code);
}
}
private:
Done done_;
};
同理,在解析器或框架模块边界注入可替换策略(如错误回调、日志桩)时,std::function 可避免把策略类型写死成模板参数而导致的头文件膨胀:
#include <functional>
#include <string_view>
class Parser {
public:
using ErrorHandler = std::function<void(std::string_view message)>;
explicit Parser(ErrorHandler on_error)
: on_error_(std::move(on_error)) {}
void report(std::string_view message) const {
if (on_error_) {
on_error_(message);
}
}
private:
ErrorHandler on_error_;
};
由于 report 仅在出错路径执行,间接调用成本远低于头文件模板化与模块耦合成本;若策略属于高频正常路径,则仍应退回模板参数。
工程上线前,还需显式核对回调的生命周期与并发边界:
- 生命周期管理:
std::function不延长内部捕获外部资源的生存期;长期存放的回调优先值捕获或智能指针,引用捕获仅限作用域严格受控且宿主保证更长寿的场景。 - 并发与同步:多线程并发只读调用同一未修改的
std::function实例本身合法,但目标内部读写共享状态仍需加锁;并发替换同一std::function成员或修改外层subscriptions_容器必须在宿主层做锁、快照或队列同步。
排查顺序
- 确认存储需求:需要长期保存、放入同构容器或跨稳定 ABI 边界时再引入 wrapper;即时消费优先模板或具体 lambda。
- 核对调用签名:确认参数转换与返回值匹配,涉及引用返回时显式写出
-> const T&并核验生命周期。 - 检查复制语义:若目标含
std::unique_ptr等只移动状态,转向 C++23std::move_only_function或自定义 move-only wrapper。 - 评估状态体积与生命期:长期保存严禁悬垂引用捕获;大状态外移至
std::shared_ptr以稳定闭包体积并提高 SOO 命中率。 - 定位调用频率并实测:高热循环优先模板/函数指针/裸 lambda;引入
std::function后用 profiler 验证构造、复制、搬迁与调用各自占比。
最小自检任务
阅读下面代码,从对象生命周期、复制语义和性能边界三个维度分析 set_handler 保存的回调存在什么问题,并给出适合长期保存在 EventSource 中的修改方案。
#include <functional>
#include <string>
#include <vector>
struct Event {
int value{};
};
class EventSource {
public:
void set_handler(std::function<void(const Event&)> handler) {
handler_ = std::move(handler);
}
void notify(const Event& event) const {
if (handler_) {
handler_(event);
}
}
private:
std::function<void(const Event&)> handler_;
};
void configure(EventSource& source) {
std::vector<int> table(1024, 7);
int limit = 10;
source.set_handler([&table, limit](const Event& event) {
if (event.value >= limit && event.value < static_cast<int>(table.size())) {
// 使用 table[event.value]
}
});
}
本章知识点总结
- 类型擦除形状
std::function<R(Args...)>固定签名并隐藏具体类型,典型实现由“目标存储区 +invoker调用入口 +manager管理入口”构成。 - 空状态与异常
默认构造或赋值为
nullptr会产生空 wrapper,调用前应显式检查operator bool(),空调用将直接抛出std::bad_function_call。 - SOO 与分配边界
小目标常可内联进内部缓冲区以省去堆分配(阈值属实现细节),但 SOO 无法消除
invoker间接调用;大捕获与容器频繁搬迁仍会放大分配和拷贝开销。 - 拷贝与移动约束
普通
std::function强制目标可复制,捕获std::unique_ptr等只移动目标需改用 C++23std::move_only_function或 move-only wrapper;函数指针与std::reference_wrapper拷贝不抛分配异常。 - 生命周期与引用返回
std::function不延长闭包内部引用目标的生存期;返回引用时必须显式声明-> const T&,防止绑定到推导出的临时对象。 - 选型与接口边界
同步即时调用优先模板参数保留内联机会,C ABI 场景可用函数指针加
void*;需要保存回调时按值接收std::function再std::move到成员,元数据放在外层结构中。 - 并发与性能排查
只读并发调用不等于目标内部线程安全,并发写或容器增删需外部同步;排查按“存储需求 → 签名与生命期 → 拷贝语义 → 调用频率与实测”顺序收口。