设计模式

全屏查看

1 创建型模式 #

mindmap
    id1[创建型模式]
        id1-1[单例模式]
            id1-1-1[饿汉式单例]
            id1-1-2[懒汉式单例]
            id1-1-3[线程安全单例]
            id1-1-4[单例模式的应用场景]
        id1-2[工厂模式]
            id1-2-1[简单工厂模式]
            id1-2-2[工厂方法模式]
            id1-2-3[抽象工厂模式]
            id1-2-4[工厂模式的选择原则]
        id1-3[建造者模式]
            id1-3-1[建造者模式的结构]
            id1-3-2[建造者与指挥者]
            id1-3-3[建造者模式的优势]
            id1-3-4[建造者模式的应用实例]
        id1-4[原型模式]
            id1-4-1[浅拷贝与深拷贝]
            id1-4-2[原型模式的实现方式]
            id1-4-3[原型注册表]
            id1-4-4[原型模式的使用场景]
单例模式
饿汉式单例
懒汉式单例
线程安全单例
单例模式的应用场景
工厂模式
简单工厂模式
工厂方法模式
抽象工厂模式
工厂模式的选择原则
建造者模式
建造者模式的结构
建造者与指挥者
建造者模式的优势
建造者模式的应用实例
原型模式
浅拷贝与深拷贝
原型模式的实现方式
原型注册表
原型模式的使用场景

2 结构型模式 #

适配器模式
类适配器
对象适配器
双向适配器
适配器模式的实际应用
装饰器模式
装饰器的组合方式
装饰器与继承的比较
装饰器模式的扩展性
C++中的装饰器实现
代理模式
静态代理
动态代理
虚拟代理
保护代理
外观模式
外观模式的简化作用
外观与子系统
外观模式的设计原则
外观模式的应用实例
桥接模式
抽象与实现的分离
桥接模式的结构
桥接模式的变化维度
桥接模式的优势
组合模式
树形结构表示
透明组合模式
安全组合模式
组合模式的操作方法
享元模式
内部状态与外部状态
享元工厂
享元模式的内存优化
享元模式的使用场景
mindmap
    id2[结构型模式]
        id2-1[适配器模式]
            id2-1-1[类适配器]
            id2-1-2[对象适配器]
            id2-1-3[双向适配器]
            id2-1-4[适配器模式的实际应用]
        id2-2[装饰器模式]
            id2-2-1[装饰器的组合方式]
            id2-2-2[装饰器与继承的比较]
            id2-2-3[装饰器模式的扩展性]
            id2-2-4[C++中的装饰器实现]
        id2-3[代理模式]
            id2-3-1[静态代理]
            id2-3-2[动态代理]
            id2-3-3[虚拟代理]
            id2-3-4[保护代理]
        id2-4[外观模式]
            id2-4-1[外观模式的简化作用]
            id2-4-2[外观与子系统]
            id2-4-3[外观模式的设计原则]
            id2-4-4[外观模式的应用实例]
        id2-5[桥接模式]
            id2-5-1[抽象与实现的分离]
            id2-5-2[桥接模式的结构]
            id2-5-3[桥接模式的变化维度]
            id2-5-4[桥接模式的优势]
        id2-6[组合模式]
            id2-6-1[树形结构表示]
            id2-6-2[透明组合模式]
            id2-6-3[安全组合模式]
            id2-6-4[组合模式的操作方法]
        id2-7[享元模式]
            id2-7-1[内部状态与外部状态]
            id2-7-2[享元工厂]
            id2-7-3[享元模式的内存优化]
            id2-7-4[享元模式的使用场景]

3 行为型模式 #

mindmap
    id3[行为型模式]
        id3-1[策略模式]
            id3-1-1[策略接口设计]
            id3-1-2[策略选择机制]
            id3-1-3[策略模式的灵活性]
            id3-1-4[策略模式的应用实例]
        id3-2[观察者模式]
            id3-2-1[发布-订阅机制]
            id3-2-2[推模型与拉模型]
            id3-2-3[观察者模式的事件处理]
            id3-2-4[观察者模式的实现变体]
        id3-3[命令模式]
            id3-3-1[命令封装]
            id3-3-2[命令队列]
            id3-3-3[撤销与重做]
            id3-3-4[命令模式的应用场景]
        id3-4[状态模式]
            id3-4-1[状态转换]
            id3-4-2[状态模式的结构]
            id3-4-3[状态模式与条件语句]
            id3-4-4[状态模式的实际应用]
        id3-5[职责链模式]
            id3-5-1[处理者链]
            id3-5-2[请求传递机制]
            id3-5-3[职责链的灵活性]
            id3-5-4[职责链模式的使用场景]
        id3-6[模板方法模式]
            id3-6-1[算法骨架]
            id3-6-2[钩子方法]
            id3-6-3[模板方法的扩展]
            id3-6-4[模板方法模式的优势]
        id3-7[访问者模式]
            id3-7-1[双重分派]
            id3-7-2[访问者接口设计]
            id3-7-3[访问者模式的结构]
            id3-7-4[访问者模式的应用限制]
        id3-8[中介者模式]
            id3-8-1[中介者的协调作用]
            id3-8-2[同事类交互]
            id3-8-3[中介者模式的解耦]
            id3-8-4[中介者模式的实际应用]
        id3-9[备忘录模式]
            id3-9-1[状态保存]
            id3-9-2[备忘录的管理]
            id3-9-3[备忘录的封装]
            id3-9-4[备忘录模式的使用场景]
        id3-10[迭代器模式]
            id3-10-1[迭代器接口]
            id3-10-2[内部迭代器与外部迭代器]
            id3-10-3[迭代器的安全性]
            id3-10-4[C++ STL中的迭代器]
        id3-11[解释器模式]
            id3-11-1[文法表示]
            id3-11-2[抽象语法树]
            id3-11-3[解释器模式的结构]
            id3-11-4[解释器模式的应用领域]
策略模式
策略接口设计
策略选择机制
策略模式的灵活性
策略模式的应用实例
观察者模式
发布-订阅机制
推模型与拉模型
观察者模式的事件处理
观察者模式的实现变体
命令模式
命令封装
命令队列
撤销与重做
命令模式的应用场景
状态模式
状态转换
状态模式的结构
状态模式与条件语句
状态模式的实际应用
职责链模式
处理者链
请求传递机制
职责链的灵活性
职责链模式的使用场景
模板方法模式
算法骨架
钩子方法
模板方法的扩展
模板方法模式的优势
访问者模式
双重分派
访问者接口设计
访问者模式的结构
访问者模式的应用限制
中介者模式
中介者的协调作用
同事类交互
中介者模式的解耦
中介者模式的实际应用
备忘录模式
状态保存
备忘录的管理
备忘录的封装
备忘录模式的使用场景
迭代器模式
迭代器接口
内部迭代器与外部迭代器
迭代器的安全性
C++ STL中的迭代器
解释器模式
文法表示
抽象语法树
解释器模式的结构
解释器模式的应用领域

4 设计模式原则 #

SOLID原则
单一职责原则
开闭原则
里氏替换原则
接口隔离原则
依赖倒置原则
其他重要原则
迪米特法则
合成复用原则
面向接口编程
高内聚低耦合
mindmap
    id4[设计模式原则]
        id4-1[SOLID原则]
            id4-1-1[单一职责原则]
            id4-1-2[开闭原则]
            id4-1-3[里氏替换原则]
            id4-1-4[接口隔离原则]
            id4-1-5[依赖倒置原则]
        id4-2[其他重要原则]
            id4-2-1[迪米特法则]
            id4-2-2[合成复用原则]
            id4-2-3[面向接口编程]
            id4-2-4[高内聚低耦合]

5 设计模式实践 #

mindmap
    id5[设计模式实践]
        id5-1[模式选择与组合]
            id5-1-1[模式的选择标准]
            id5-1-2[模式的组合使用]
            id5-1-3[模式的权衡取舍]
            id5-1-4[反模式识别]
        id5-2[C++特性与设计模式]
            id5-2-1[模板与设计模式]
            id5-2-2[智能指针的应用]
            id5-2-3[RAII与设计模式]
            id5-2-4[现代C++中的模式实现]
        id5-3[设计模式在项目中的应用]
            id5-3-1[框架设计中的模式]
            id5-3-2[库设计中的模式]
            id5-3-3[应用程序中的模式]
            id5-3-4[重构与模式应用]
        id5-4[性能与模式]
            id5-4-1[模式对性能的影响]
            id5-4-2[模式优化的技巧]
            id5-4-3[内存管理与模式]
            id5-4-4[并发环境下的模式应用]
模式选择与组合
模式的选择标准
模式的组合使用
模式的权衡取舍
反模式识别
C++特性与设计模式
模板与设计模式
智能指针的应用
RAII与设计模式
现代C++中的模式实现
设计模式在项目中的应用
框架设计中的模式
库设计中的模式
应用程序中的模式
重构与模式应用
性能与模式
模式对性能的影响
模式优化的技巧
内存管理与模式
并发环境下的模式应用