Skip to main content

Chapter 35: Std Function

核心问题与阅读主线

本章导读5 个核心小节 · 附自检与总结

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_ 容器必须在宿主层做锁、快照或队列同步。

排查顺序

  1. 确认存储需求:需要长期保存、放入同构容器或跨稳定 ABI 边界时再引入 wrapper;即时消费优先模板或具体 lambda。
  2. 核对调用签名:确认参数转换与返回值匹配,涉及引用返回时显式写出 -> const T& 并核验生命周期。
  3. 检查复制语义:若目标含 std::unique_ptr 等只移动状态,转向 C++23 std::move_only_function 或自定义 move-only wrapper。
  4. 评估状态体积与生命期:长期保存严禁悬垂引用捕获;大状态外移至 std::shared_ptr 以稳定闭包体积并提高 SOO 命中率。
  5. 定位调用频率并实测:高热循环优先模板/函数指针/裸 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++23 std::move_only_function 或 move-only wrapper;函数指针与 std::reference_wrapper 拷贝不抛分配异常。

  • 生命周期与引用返回

    std::function 不延长闭包内部引用目标的生存期;返回引用时必须显式声明 -> const T&,防止绑定到推导出的临时对象。

  • 选型与接口边界

    同步即时调用优先模板参数保留内联机会,C ABI 场景可用函数指针加 void*;需要保存回调时按值接收 std::function 再 std::move 到成员,元数据放在外层结构中。

  • 并发与性能排查

    只读并发调用不等于目标内部线程安全,并发写或容器增删需外部同步;排查按“存储需求 → 签名与生命期 → 拷贝语义 → 调用频率与实测”顺序收口。