C语言设计模式实战:用函数指针与不透明指针重构23种经典模式
最近整理自己的代码仓库,翻出三年前学 Java 时抄的那一沓设计模式笔记,忽然有点感慨。当时花了大把精力背策略模式、观察者模式、工厂模式的类图,以为掌握了某种武功秘籍,结果一转到 C 语言项目里,发现 class、interface、abstract 这些词全没了,第一反应是"这玩意儿在 C 里怎么活"。
后来在嵌入式项目里写久了,反而想明白一件事:设计模式从来不是 Java 的私产,它是一批老前辈在大量工程里总结出来的"解决重复问题的手段"。语言只是工具,C 没有类,但有结构体,有函数指针,有不透明指针——这些足够把大部分模式的"魂"完整落地。这也是我想用 C 重讲设计模式的原因:剥掉语言糖衣,直接看骨架。
这篇文章不打算给你贴 23 张 UML 图,而是用 C 语言的实际代码,把设计模式重新拆开。适合三类人看:写 C/C++/嵌入式但觉得设计模式"用不上"的开发者;学过 Java 版设计模式,想看看跨语言思路的人;以及正在纠结"C 语言项目怎么组织才能不烂尾"的工程实践者。我尽量少讲术语,多给能直接抄的代码和踩过的坑。
1. 为什么是 C?设计模式从来不是面向对象的专利
先说清一个容易被误解的点:设计模式的定义是"在特定场景下,针对反复出现的问题的可复用解决方案",而不是"类的排列组合"。
1.1 设计模式本质是"结构和行为",不是"类和对象"
GoF 那本《设计模式——可复用面向对象软件的基础》确实是用 Smalltalk 和 C++ 写的示例,但书里反复强调的核心不是继承、多态这些语法特性,而是"封装变化点""面向接口编程""优先使用组合而不是继承"这样的设计原则。
这些原则在 C 里一样成立。举个最生活化的例子:你下楼买个早餐,告诉老板"不要葱,多放辣"。老板不用知道你是谁、你长什么样、你有没有车,他只关心你要什么。这就是策略模式里"把变化点参数化"的思想——把"加不加葱""辣度多少"这些可变行为暴露出来,而不是写死一套流程。
C 语言没有 class 关键字,但它有 struct,可以聚合数据和行为指针;它有函数指针,可以在运行时动态决定"调用哪个函数";它有不透明指针,可以在头文件里藏住全部实现细节。这三样东西组合起来,已经能构造出和"接口""多态""封装"等价的能力。而且因为没有语言糖,每一步都是显式的,你在读 C 代码时能清楚看到"间接层"在哪、数据归谁管。
1.2 C 的两把钥匙:不透明指针与函数指针
如果只让我留两样东西来"翻译"设计模式,我选不透明指针和函数指针。
不透明指针解决的是封装问题。你在头文件里写 typedef struct Logger Logger;,外面所有模块都拿 Logger* 用,但 struct Logger 真正的成员只放在 .c 文件里。这就相当于 Java 里的 private 字段——外面想改内部结构?门都没有。它的好处是接口稳定、编译依赖少、ABI 干净,在大型 C 项目里几乎是一等一的代码组织手段。
函数指针解决的是多态问题。C++ 的虚函数表,说白了就是一个结构体里存了一堆函数指针,每个对象带一个指向该表的隐藏指针。C 里你完全可以自己造一个:
这个 device_ops 就是 C 版的"接口":一个设备只要实现了 open/close/read,就可以被塞进 struct device 使用。调用方完全不关心底下的具体实现是串口、SPI Flash 还是网络 socket——只需要 dev->ops->read(dev->priv, buf, n)。这不是多态是什么?
1.3 谁适合用这套思路
写应用层的人可能会觉得"我在 C++ 里直接用 virtual 不香吗",对,香,但理解结构更重要。而如果你在写嵌入式固件、写操作系统内核模块、写底层库,或者困在 C 的老项目里常年被几千行函数埋在坑里,那这套思路就是及时的——它能让代码从"一坨能跑的 C"变成"有骨架的 C"。
2. 用 C 落地设计模式的三个基本功
在真正写模式之前,先把三个基本功练扎实。这三个东西是所有 C 版设计模式的地基,地基不稳,后面全是空中楼阁。
2.1 封装的第一层:不透明指针
大多数教材讲封装,举的例子是"类成员默认私有"。C 里没有访问修饰符,只有头文件公开 + 源文件隐藏的约定,而这个约定靠不透明指针完成。
先在 logger.h 里给全世界看的接口:
然后在 logger.c 里定义真实结构:
如果哪天你想加一个写缓冲、加一个异步刷盘字段,只要改 logger.c,所有头文件的使用者完全无感。这是"封装"在小项目里最容易被忽视、却最值钱的收益:修改内部实现不波及外部代码。
注意:不透明指针要求所有分配、销毁都走你提供的函数,绝对不能在外面拿
sizeof(Logger)或者强转成一个自定义类型来读成员。写库给别人用的时候,一定要在文档里写清楚"这个结构体是不完整的,禁止访问成员"。
2.2 多态的第一课:行为表
上面 device_ops 的例子就是行为表。它的核心思想是"把一组可变的操作集中到一个结构体里,用一个公共的入口去调用"。相较于 C++ 的虚表,C 的版本更直白:谁能干活,就把谁的函数塞到这张表里。
使用它的完整形态通常是这样:
这个模式在 C 世界极其常见,Linux 内核里的 file_operations、driver_ops,都是一张函数指针表。你甚至可以扩展出"继承":在结构体开头嵌入一个基础行为表,后面跟上扩展字段。
2.3 唯一的组合方式:嵌套结构体与指针
Java/C++ 的继承可以毫不费力地复用父类行为,C 里没有这种语法。但 GoF 早就说过"优先使用组合而不是继承",C 恰好把这句话变成了唯一选择:你要复用功能,就把小的结构体塞进大的结构体,或者用指针指向它。
组合让代码的关系变得非常清晰:reliable_device 有一个 retry_policy,而不是"是一个"retry_policy。这在语义上更接近真实世界,也避免了深继承链带来的混乱。缺点是访问层级深了写起来啰嗦,不过配合少量辅助函数,这个缺点完全可以接受。
3. 五个经典模式在 C 里的完整落地
地基打好了,看看五个具体模式在 C 里怎么长出来。我刻意选了嵌入式、网络服务、中间件开发里最高频的几个,每一个都给了可编译的核心代码,你在自己项目里可以直接改改结构体名字就拿去用。
3.1 策略模式:qsort 早就替我们上了第一课
很多人不知道,C 标准库的 qsort 就是策略模式的教科书级案例。排序算法是固定的,但"两个元素怎么比较"是变化的,所以 qsort 把一个函数指针当作参数暴露了出来:
如果你写过业务代码,大概率会遇到"同一个流程,不同客户要求不同折扣""同一个报表,不同领导要不同排序"这种需求。直接用 if/else 堆,每加一种情况就要动一次主流程;改成函数指针参数后,新策略就是一个新函数,加一行注册就完事。
还有更"策略模式"味道的做法:把策略集中放在一个结构体里,运行时切换。
这样扩展新策略就像数组加元素,主业务逻辑一行都不用改。这正是策略模式的终极目标:把算法从使用它的客户端中独立出来,让它可替换、可测试。
3.2 观察者模式:事件总线与回调注册表
C 项目里的"事件回调",本质就是观察者模式。网络库、GUI 框架、信号处理,到处都是。用 C 实现观察者,最直观的方式就是"订阅者链表 + 发布遍历"。
先定义订阅节点和引擎:
订阅和发布就是链表操作和遍历:
注意两点:一是 ctx 参数极其重要——回调必须能拿到"你当初订阅时的心智上下文",没有它你就得依赖全局变量,全局变量一多,程序就失控了;二是在多线程环境下发布事件时,需要考虑订阅者被移除的竞态,通常加一个锁或采用 RCU 方案。单线程应用里这个写法简单又够用,很多嵌入式的按键中断、定时器事件分发,落地版本和上面的代码八九不离十。
3.3 状态模式:函数指针跳转表
嵌入式里最常见的状态模式是网络连接状态机、按键扫描状态机、协议解析状态机。用函数指针实现状态机,比用大量 switch 维护起来舒服一百倍,因为新增一个状态就是新增一个函数+一条表项,主循环不用动。
核心结构是这样:
每个状态一个动作函数,动作函数根据事件决定状态迁移:
状态机的调度器只需要一张查找表:当前状态 + 事件 -> 动作函数。复杂点还可以用二维表:行是状态,列是事件,表里存"下一个状态 + 动作",这就是状态转移表的思路,在通信协议栈里非常常用。相比 switch (state) + switch (event) 的叠加代码,表格驱动状态机的优势是"结构即数据",改逻辑不用追代码,直接把表改掉就行,肉眼就能检查完整性。
3.4 单例模式:静态实例与初始化时机
单例在 C 里的实现相当朴素:用文件作用域的静态变量保存实例,对外只提供一个获取函数。它通常用在日志器、配置管理器、全局线程池这些"全程序只有一份"的对象上。
这个写法在单线程程序里完全没问题,但在多线程环境下有竞态:两个线程同时调用 logger_instance(),可能创建两个实例。C11 标准提供了 call_once 和原子操作,可以稳妥地解决这个问题:
实操提醒:单例模式最大的麻烦不是"怎么只有一个实例",而是生命周期。程序退出时谁先释放?如果 A 模块的析构函数还握着日志器指针,B 模块已经把日志器销毁了,就会出现难排查的崩溃。我的习惯是:单例对象不主动销毁,交给操作系统回收,除非它持有非常稀缺的资源(比如数据库连接),那也要安排明确的 shutdown 顺序。
3.5 工厂模式:注册表就是没有 class 的工厂
C 里写工厂,最常见的是注册表模式:一个"名称 -> 创建函数"的映射表,新的组件类型只需要注册进去,使用方就能通过名字创建,而不需要知道具体类型是什么。这种设计在插件系统、序列化格式注册、驱动框架里非常管用。
使用方只需要调用 factory_register("json", json_serializer_create) 把"JSON 序列化器"注册进去;业务逻辑里要创建 JSON 序列化器,就 factory_create("json", NULL),完全不知道也不关心 json_serializer_t 的内部结构。新增一种序列化格式,业务侧一行不改,这就是开闭原则在 C 里的落地。
4. 实操中踩过的坑与总结的经验
理论说得再漂亮,动手立刻就能感受到差距。这部分是我在真实项目里踩过、补过、最后总结出的经验,比模式骨架本身体积大得多,也值钱得多。
4.1 函数指针的类型声明:丑,但可以驯服
C 的函数指针声明确实反人类:void (*handler)(const event_t *, void *),稍复杂一点就变成天书。解决办法只有一个字:typedef。给函数指针起别名,能大幅提高可读性:
这样写订阅函数时,签名是"普通"的:
任何人读代码都能直接理解,不用被一长串 (*...) 干扰。还有一个进阶习惯:函数指针的 const 语义。const struct device_ops *ops 表示"函数表本身不可修改",这是保护只读数据不被动的好习惯,C 里没有虚表不可写的强制要求,全靠你自己加 const。
4.2 内存所有权:谁创建,谁释放
这是 C 版设计模式里最要命的一条纪律。用结构体和指针组合对象时,随手一个 return ctx,很容易造成调用方不知道到底该谁来 free。我的约定是三条:
- 创建函数负责分配内存,销毁函数负责释放自己分配的内存;
- 组合关系里的"包含方"负责释放被包含方;
- 只借用不拥有的指针,内部赋值的时候绝不随便
free。
比如事件总线 event_bus,头文件里明确注释"created by event_bus_create, destroyed by event_bus_destroy"。这样哪怕后来别人来维护,遇到"总线持有订阅者注册数据"的问题,也能一眼看清所有权归属,不会出现 double-free 或 use-after-free。
4.3 上下文指针:回调函数里那个 void * 别嫌丑
观察者、策略、状态模式都会大量用到回调。回调函数被调用的环境往往离注册处十万八千里,如果没有"上下文指针",就得把状态塞进全局变量。全局变量的危害不必多说——多实例、测试隔离、并发安全全是坑。
所以我的看法是:回调函数里那个 void *ctx 是 C 语言里最被低估的参数。它虽然看着丑,但它把"调用者是谁、有什么状态"完整地传给回调函数,是 C 里实现"闭包"最朴素的方案。写库接口时宁可多保留一个 void *ctx 参数,也别省。它不占多少代码,却能在半年后调试时帮你少掉一半头发。
4.4 错误处理策略:别把错误吞了
设计模式能优化结构,但不解决错误处理。用函数指针注册回调后,回调里的错误往往被上层"广播"出去,如果没有良好的错误传递机制,错误就会被吞掉。
C 里常见且易用的做法是"返回值 + 输出参数 + 错误码"。函数可以返回操作是否成功,错误细节放进 errno 或一个自定义错误码结构。在状态机和工厂场景里,一定要设计"创建失败返回 NULL"之类明确的语义,调用方不能假设注册一定成功、创建一定成功。我在工厂代码里加了边界检查 g_factory_count >= 32,就是血的教训——早期没有检查,注册表溢出把后续内存写坏,出现难以复现的随机崩溃。
4.5 命名与文件组织的建议
用 C 实现面向对象式的设计,最忌命名混乱。我采用一套简单的约定,团队新人也容易上手:
- 类型名用
typedef struct xxx_t,前缀统一是模块名,比如logger_t、event_bus_t; - 操作函数统一用"模块名_动词"前缀,如
logger_write、event_bus_publish; - 每个模块一个 .h/.c 对,.h 只留公开类型声明和函数声明,.c 里放完整的 struct 定义和实现;
- 行为表里函数指针成员统一小写动词开头,如
open、close,和调用方代码风格区分开。
这套约定最大的价值是"看到函数名就知道它属于哪个模块",再配合文件分目录,大型 C 项目就能保持基本可维护性。
5. 常见问题排查速查表
最后整理一张我在实践中高频遇到的问题排查表,希望能帮你在遇到类似情况时少走几步弯路。
| 现象 | 常见原因 | 解决方案 |
|---|---|---|
| 程序一调用函数指针就段错误 | 函数指针未初始化,或者初始化成了 NULL | 在行为表里逐个成员赋初值,加 .open = uart_open 这种显式初始化;调用前检查 ops->open != NULL |
| 回调触发了两次或一次都没触发 | 订阅链表重复插入 / 忘记注册 | 订阅前查重;统一走 event_bus_subscribe 入口,别手动操作链表 |
| 函数指针调用时访问对象字段崩溃 | 传错了上下文指针,void *ctx 被强转成错误类型 |
先确认注册订阅时的 ctx 类型,打印 ctx 地址比对是否一致;考虑用 wrapper 把真实类型包一层 |
| 单例获取到空指针 | 初始化函数没被调用,或静态初始化顺序问题 | 检查 call_once 或首次调用时机;不要在 static 变量的初始化里调用其他模块单例 |
| 释放后还有代码在回调 | 观察者订阅者被 free 后,事件总线仍持有其指针 |
退订时从链表中摘除节点,或增加引用计数,在回调里判断"已退订标志位" |
| 函数指针声明太复杂编译报错 | C 的函数指针类型语法写错 | 全部改成 typedef 别名;使用 typedef 可以显著降低声明出错概率 |
| 工厂注册的函数类型不匹配 | 创建函数参数或返回值与 create_fn 不一致 |
注册时增加宏或者静态断言检查 __typeof__,或统一参数为 const char * |
| 状态机在特定事件下不动 | 状态表漏掉某个"状态+事件"组合 | 状态表里设置默认转移项,处理未知事件,否则就打印日志提醒 |
整理这张表的时候,我特意想了下最值得反复强调的一条:模式落地的核心从来不是代码长得像某个图,而是代码在日后被改的时候会不会变乱、会不会崩溃。设计模式给你的是"结构化变更"的思路,C 语言给你的工具是结构体、函数指针和不透明指针,把两件事结合起来,才是真正解决工程问题。
我自己在写完这套 C 版模式笔记之后,最大的体会是:以前学 Java 模式容易陷入"背类图"的误区,总觉得记住几个箭头就好了。反而是在 C 里手动实现虚函数表、事件总线、状态跳转表的过程中,逼着自己去思考"这里为什么要一个间接层"、"这个数据到底归谁拥有"。这些思考才是模式真正的营养。如果你也在用 C/C++ 做项目,建议挑一个模式,在你的真实代码里试试用行为表替换那一大堆 if/else,体会一下结构的力量,这比你读十篇教程都管用。