C++ 设计模式全总结

文档说明

本文档完整覆盖 GoF 23 种设计模式 ，基于 C++ 语言特性（封装、继承、多态、 RAII、智能指针等）整理，分为创建型、结构型、行为型 三大类；每类模式包含核心定义、C++ 适用场景、设计思想、空文档链接、核心对比，文末附全模式汇总表，适合 C++ 开发学习、面试、工程实践参考。

一、创建型设计模式（5种）

核心定位

专注对象的创建过程，解耦「对象创建」与「对象使用」，隐藏对象实例化的细节，提升代码灵活性、可扩展性。

1. 单例模式（Singleton）

核心定义：保证一个类全局仅有一个实例，并提供全局访问点，禁止外部实例化和拷贝。
C++ 适用场景：日志管理器、配置管理器、数据库连接池、线程池等全局唯一组件。
设计思想：私有化构造/析构/拷贝函数，静态成员变量存储唯一实例，线程安全（C++11 静态局部变量最优实现）。
文档链接：<>
关键对比：
- 饿汉式：程序启动即创建，线程安全，无延迟，占用启动资源；
- 懒汉式：首次使用创建，延迟加载，非线程安全需加锁；
- C++11 静态局部变量：天然线程安全，最优实现，替代传统懒汉。

2. 工厂方法模式（Factory Method）

核心定义：定义创建对象的抽象工厂接口，由子类决定实例化哪个具体类，对象创建延迟到子类。
C++ 适用场景：需要灵活创建不同类型对象，且对象有统一接口的场景（如日志输出器、文件解析器）。
设计思想：抽象产品 + 具体产品 + 抽象工厂 + 具体工厂，遵循开闭原则。
文档链接：<>
关键对比：
- 简单工厂：一个工厂创建所有对象，违反开闭原则，适合少量固定对象；
- 工厂方法：一个工厂对应一个产品，扩展方便，符合开闭原则。

3. 抽象工厂模式（Abstract Factory）

核心定义：提供创建一系列相关/依赖对象的接口，无需指定具体类。
C++ 适用场景：跨平台UI组件、数据库驱动（连接+语句+结果集）、多系列产品族。
设计思想：抽象工厂定义多产品创建接口，具体工厂生产一整套产品，产品族内对象强关联。
文档链接：<>
关键对比：
- 工厂方法：生产单一产品，聚焦纵向扩展；
- 抽象工厂：生产产品族，聚焦横向扩展，新增产品族易，新增产品难。

4. 建造者模式（Builder）

核心定义：将复杂对象的构建与「表示分离」，相同构建过程可创建不同表示。
C++ 适用场景：创建参数多、步骤复杂的对象（如电脑、汽车、HTTP请求）。
设计思想：抽象建造者 + 具体建造者 + 指挥者 + 产品，分离组装逻辑与细节。
文档链接：<>
关键对比：
- 工厂模式：关注「产品是什么」，快速创建完整对象；
- 建造者模式：关注「产品怎么造」，分步组装复杂对象。

5. 原型模式（Prototype）

核心定义：通过复制（克隆）现有对象创建新对象，避免重复初始化开销。
C++ 适用场景：对象创建成本高、需要大量相似对象、动态创建对象的场景。
设计思想：抽象原型类定义克隆接口，具体原型实现深拷贝/浅拷贝，C++ 用拷贝构造/智能指针实现。
文档链接：<>
关键对比：
- 浅拷贝：复制指针地址，多个对象共享资源，存在悬空风险；
- 深拷贝：复制指针指向的资源，对象独立，C++ 必须实现深拷贝避免内存问题。

二、结构型设计模式（7种）

核心定位

专注类/对象的组合结构，通过继承、组合、封装等方式，将类/对象组装成更大的结构，优化代码结构与复用。

1. 适配器模式（Adapter）

核心定义：将一个类的接口转换成客户端期望的另一个接口，解决接口不兼容问题。
C++ 适用场景：兼容旧接口、第三方SDK适配、不同系统接口对接。
设计思想：类适配器（多继承）、对象适配器（组合，C++ 推荐），目标接口 + 适配者 + 适配器。
文档链接：<>
关键对比：
- 类适配器：多继承，耦合高，C++ 慎用；
- 对象适配器：组合实现，低耦合，符合合成复用原则，工程首选。

2. 桥接模式（Bridge）

核心定义：将抽象与实现分离，通过桥接接口连接，两者可独立扩展。
C++ 适用场景：类存在两个独立变化维度（如形状+颜色、设备+遥控器）。
设计思想：抽象类 + 实现类接口，用组合替代多继承，避免类爆炸。
文档链接：<>
关键对比：
- 继承：强耦合，维度扩展会导致类数量指数增长；
- 桥接：组合解耦，两个维度独立扩展，无类爆炸。

3. 装饰器模式（Decorator）

核心定义：动态给对象添加额外功能，不改变原有类结构，比继承更灵活。
C++ 适用场景：动态增强对象功能、日志增强、权限校验、IO流包装。
设计思想：抽象组件 + 具体组件 + 抽象装饰器 + 具体装饰器，嵌套组合扩展功能。
文档链接：<>
关键对比：
- 继承：静态扩展，编译时确定功能，代码冗余；
- 装饰器：动态扩展，运行时增减功能，无冗余，符合开闭原则。

4. 组合模式（Composite）

核心定义：将对象组织成树形结构，客户端统一对待「单个对象」和「组合对象」。
C++ 适用场景：文件系统、菜单树、组织架构、树形控件。
设计思想：抽象节点 + 叶子节点 + 组合节点，统一接口操作整体与部分。
文档链接：<>
关键对比：
- 普通结构：需区分单个/组合对象，代码冗余；
- 组合模式：统一接口，简化客户端调用，天然适配树形结构。

5. 外观模式（Facade）

核心定义：为复杂子系统提供统一的高层接口，简化客户端调用，隐藏子系统细节。
C++ 适用场景：封装复杂第三方库、简化多模块调用、系统入口封装。
设计思想：外观类封装子系统调用逻辑，客户端仅与外观类交互。
文档链接：<>
关键对比：
- 直接调用：客户端依赖多个子系统，耦合高；
- 外观模式：单一入口，解耦客户端与子系统，降低使用成本。

6. 享元模式（Flyweight）

核心定义：共享大量细粒度对象，复用内存，减少对象创建数量，优化性能。
C++ 适用场景：大量相似对象（如字符串池、线程池、连接池、游戏粒子）。
设计思想：享元工厂 + 内部状态（共享）+ 外部状态（独立），C++ 用map管理共享对象。
文档链接：<>
关键对比：
- 普通创建：每个对象独立内存，占用高；
- 享元模式：共享复用，大幅降低内存占用，适合海量相似对象。

7. 代理模式（Proxy）

核心定义：为对象提供代理对象，控制对原对象的访问，增强/限制原对象功能。
C++ 适用场景：远程代理、虚拟代理、安全代理、日志代理、延迟加载。
设计思想：抽象主题 + 真实主题 + 代理主题，代理与原对象实现同一接口。
文档链接：<>
关键对比：
- 装饰器：增强对象功能，客户端无感知；
- 代理：控制对象访问，隐藏原对象细节，侧重权限/隔离。

三、行为型设计模式（11种）

核心定位

专注对象之间的通信、职责分配、算法流程，描述对象间如何协作完成任务，优化流程与交互逻辑。

1. 责任链模式（Chain of Responsibility）

核心定义：将请求处理者连成一条链，请求沿链传递，直到有对象处理。
C++ 适用场景：多级审批、日志分级、请求过滤、异常处理链。
设计思想：抽象处理者 + 具体处理者，每个处理者持有下一个处理者引用。
文档链接：<>
关键对比：
- 硬编码判断：if-else嵌套，耦合高，扩展难；
- 责任链：动态增减处理者，解耦请求发送者与处理者。

2. 命令模式（Command）

核心定义：将请求封装为对象，分离请求发起者与执行者，支持撤销/排队/日志。
C++ 适用场景：菜单命令、事务操作、撤销/重做、任务队列。
设计思想：抽象命令 + 具体命令 + 接收者 + 调用者，请求对象化。
文档链接：<>
关键对比：
- 直接调用：发起者与执行者强耦合；
- 命令模式：解耦，易扩展命令，支持高级功能（撤销、队列）。

3. 解释器模式（Interpreter）

核心定义：为特定语言定义语法规则，并构建解释器处理语法。
C++ 适用场景：简单表达式解析、配置文件解析、自定义规则引擎。
设计思想：抽象表达式 + 终结符/非终结符表达式，上下文存储全局信息。
文档链接：<>
关键对比：
- 硬编码解析：代码混乱，规则修改难；
- 解释器：规则模块化，易扩展语法，适合简单场景。

4. 迭代器模式（Iterator）

核心定义：提供遍历集合对象的统一方式，不暴露集合内部结构。
C++ 适用场景：自定义容器遍历、兼容STL迭代器、统一遍历接口。
设计思想：抽象迭代器 + 具体迭代器 + 抽象集合 + 具体集合，C++ STL 原生支持。
文档链接：<>
关键对比：
- 直接遍历：暴露集合内部结构，耦合高；
- 迭代器：统一遍历接口，隐藏实现，支持多种遍历方式。

5. 中介者模式（Mediator）

核心定义：用中介对象封装多个对象的交互，对象间不直接引用，降低耦合。
C++ 适用场景：多组件复杂交互（如聊天室、表单校验、UI控件交互）。
设计思想：抽象中介者 + 具体中介者 + 抽象同事类，交互集中在中介者。
文档链接：<>
关键对比：
- 网状交互：对象两两依赖，维护困难；
- 中介者：星型交互，依赖集中，易维护。

6. 备忘录模式（Memento）

核心定义：捕获对象内部状态，并在不破坏封装的前提下恢复状态。
C++ 适用场景：撤销/重做、游戏存档、编辑器恢复。
设计思想：发起人 + 备忘录 + 管理者，仅发起人可访问备忘录状态。
文档链接：<>
关键对比：
- 直接存储状态：破坏封装，暴露内部细节；
- 备忘录：封装状态，安全恢复，不暴露实现。

7. 观察者模式（Observer）

核心定义：定义一对多依赖，一个主题变化，所有观察者自动通知更新。
C++ 适用场景：事件监听、消息推送、UI数据绑定、发布订阅系统。
设计思想：抽象主题 + 具体主题 + 抽象观察者 + 具体观察者，C++ 用函数指针/回调实现。
文档链接：<>
关键对比：
- 硬编码通知：耦合高，新增观察者需修改代码；
- 观察者：动态增删观察者，符合开闭原则，解耦发布与订阅。

8. 状态模式（State）

核心定义：将对象的状态封装为独立类，状态变化时切换行为，消除大量if-else。
C++ 适用场景：对象状态多、行为随状态变化（如订单状态、电梯状态、游戏角色状态）。
设计思想：环境类 + 抽象状态 + 具体状态，行为委托给当前状态对象。
文档链接：<>
关键对比：
- if-else/switch：代码臃肿，扩展难，易出错；
- 状态模式：状态模块化，易扩展状态，逻辑清晰。

9. 策略模式（Strategy）

核心定义：定义一系列算法，封装每个算法，使其可互相替换，算法独立变化。
C++ 适用场景：多种排序算法、支付方式、压缩算法、路由策略。
设计思想：上下文 + 抽象策略 + 具体策略，运行时切换算法。
文档链接：<>
关键对比：
- 状态模式：基于状态切换行为，状态间互斥；
- 策略模式：基于算法切换行为，算法平等可替换。

10. 模板方法模式（Template Method）

核心定义：定义算法的骨架流程，将具体步骤延迟到子类实现，不改变流程结构。
C++ 适用场景：固定流程、框架封装、数据解析、游戏关卡流程。
设计思想：抽象类定义模板方法（final禁止重写）+ 抽象步骤，子类实现步骤。
文档链接：<>
关键对比：
- 子类重写整个流程：代码冗余，流程混乱；
- 模板方法：固定骨架，复用流程，仅扩展步骤，符合开闭原则。

11. 访问者模式（Visitor）

核心定义：不改变元素类，定义作用于元素的新操作，将数据结构与操作分离。
C++ 适用场景：数据结构稳定，需频繁新增操作（如报表生成、语法树遍历）。
设计思想：抽象访问者 + 具体访问者 + 抽象元素 + 具体元素 + 对象结构。
文档链接：<>
关键对比：
- 直接在元素类加操作：违反开闭原则，代码臃肿；
- 访问者：操作与结构分离，易新增操作，适合稳定数据结构。

四、全设计模式核心对比汇总表

分类	模式名称	核心解决问题	C++ 核心关键词	易混淆模式对比
创建型	单例	全局唯一实例	静态实例、线程安全	无（独立）
创建型	工厂方法	单一对象创建	抽象工厂、开闭原则	简单工厂（固定）、抽象工厂（产品族）
创建型	抽象工厂	产品族创建	多产品接口、横向扩展	工厂方法（单一产品）
创建型	建造者	复杂对象分步创建	指挥者、深拷贝	工厂（快速创建）
创建型	原型	对象克隆复用	深拷贝、clone接口	无（独立）
结构型	适配器	接口不兼容	组合适配、接口转换	桥接（分离维度）
结构型	桥接	多维度扩展	抽象+实现分离、组合	适配器（兼容）、装饰器（增强）
结构型	装饰器	动态增强功能	嵌套包装、运行时扩展	代理（控制访问）、继承（静态）
结构型	组合	树形结构统一处理	叶子+组合、统一接口	无（独立）
结构型	外观	简化复杂调用	统一入口、封装子系统	中介者（解耦交互）
结构型	享元	海量对象内存优化	共享对象、内部状态	无（独立）
结构型	代理	控制对象访问	代理对象、权限隔离	装饰器（增强功能）
行为型	责任链	多级请求处理	链式传递、解耦处理	无（独立）
行为型	命令	请求对象化	命令封装、撤销/队列	无（独立）
行为型	解释器	语法规则解析	表达式、上下文	无（独立）
行为型	迭代器	集合遍历	统一遍历、隐藏结构	无（独立）
行为型	中介者	多对象复杂交互	中介解耦、星型结构	外观（封装子系统）
行为型	备忘录	状态恢复	状态封装、存档/撤销	无（独立）
行为型	观察者	一对多通知	发布订阅、自动更新	无（独立）
行为型	状态	状态驱动行为	状态类、消除if-else	策略（算法切换）
行为型	策略	算法灵活替换	策略接口、运行切换	状态（状态切换）
行为型	模板方法	固定流程扩展	骨架流程、子类步骤	无（独立）
行为型	访问者	稳定结构新增操作	双分派、操作分离	无（独立）

五、C++ 设计模式核心汇总说明

1. 三大类核心区别

创建型 ：管「怎么造对象」，解决对象创建耦合、复杂、冗余问题；
结构型 ：管「怎么组对象」，解决接口不兼容、结构臃肿、复用低效问题；
行为型 ：管「对象怎么协作」，解决交互混乱、职责不清、流程僵化问题。

2. C++ 设计模式核心原则（必须遵守）

开闭原则：对扩展开放，对修改关闭；
合成复用原则：优先组合，少用继承；
依赖倒置：依赖抽象，不依赖具体；
接口隔离：接口单一，不冗余；
迪米特法则：最少知道，降低耦合。

3. C++ 工程实践建议

不盲目使用模式，简单场景优先简洁代码；
多态、智能指针、RAII 是 C++ 实现设计模式的核心特性；
高频实用模式：单例、工厂、适配器、装饰器、观察者、策略、模板方法；
复杂模式（访问者、解释器、享元）仅在特定场景使用，避免过度设计。

4. 学习路径

基础（创建型）→ 进阶（结构型）→ 高阶（行为型）→ 模式组合实战 → 项目重构优化

总结

本文完整覆盖 23 种 GoF 设计模式 ，按创建型、结构型、行为型分类，适配 C++ 语言特性；
每个模式包含定义、场景、思想、空链接、核心对比，可直接填充细节形成完整文档；
文末汇总表清晰区分模式用途、易混淆点，C++ 开发可快速查阅、学习、面试使用；
核心遵循设计原则，拒绝过度设计，优先实用、简洁、可维护的工程实现。