设计模式：23种模式“简介”

最新推荐文章于 2025-10-27 08:27:52 发布

原创最新推荐文章于 2025-10-27 08:27:52 发布 · 1.1k 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #C++

设计模式专栏收录该内容

15 篇文章

订阅专栏

23种设计模式的简明全景图

创建型模式（5种）

单例模式（Singleton）

确保一个类只有一个实例，并提供全局访问点。

工厂方法模式（Factory Method）

定义一个创建对象的接口，但由子类决定实例化哪个类。

抽象工厂模式（Abstract Factory）

提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。

建造者模式（Builder）

将一个复杂对象的构建与其表示分离，使同样的构建过程可以创建不同的表示。

原型模式（Prototype）

通过复制现有对象来创建新对象，而不是通过实例化。

结构型模式（7种）

适配器模式（Adapter）

将一个类的接口转换成客户期望的另一个接口。

桥接模式（Bridge）

将抽象部分与实现部分分离，使它们可以独立变化。

组合模式（Composite）

将对象组合成树形结构以表示“部分-整体”的层次结构。

装饰器模式（Decorator）

动态地给对象添加额外的职责，是继承的替代方案。

外观模式（Facade）

提供一个统一的接口，用来访问子系统中的一群接口。

享元模式（Flyweight）

通过共享技术有效地支持大量细粒度对象。

代理模式（Proxy）

为其他对象提供一种代理以控制对这个对象的访问。

行为型模式（11种）

责任链模式（Chain of Responsibility）

将请求的发送者和接收者解耦，使多个对象都有机会处理请求。

命令模式（Command）

将请求封装为对象，以便参数化客户端。

解释器模式（Interpreter）

给定一个语言，定义它的文法的一种表示，并定义一个解释器。

迭代器模式（Iterator）

提供一种方法顺序访问一个聚合对象中的各个元素。

中介者模式（Mediator）

定义一个对象来封装一系列对象的交互方式。

备忘录模式（Memento）

在不破坏封装性的前提下，捕获并外部化一个对象的内部状态。

观察者模式（Observer）

定义对象间的一对多依赖，当一个对象状态改变时，所有依赖者会收到通知。

状态模式（State）

允许对象在内部状态改变时改变它的行为。

策略模式（Strategy）

定义一系列算法，封装每个算法，并使它们可以互换。

模板方法模式（Template Method）

定义一个算法的骨架，将某些步骤延迟到子类中实现。

访问者模式（Visitor）

表示一个作用于某对象结构中的各元素的操作。

用最通俗的方式分类解析，附C++关键实现要点：

一、创建型模式（5种）

工厂方法模式
- 口诀："子类决定生产什么"
- C++：虚工厂方法 + 具体产品类
```
class Creator {
public:
    virtual Product* factoryMethod() = 0;
};
```

抽象工厂模式

口诀："工厂的工厂，生产产品族"
C++：多个关联的工厂方法

class GUIFactory {
public:
    virtual Button* createButton() = 0;
    virtual Checkbox* createCheckbox() = 0;
};

单例模式

口诀："全局唯一访问点"
C++：静态实例 + 私有构造

class Singleton {
    static Singleton& get() { 
        static Singleton instance; 
        return instance;
    }
};

建造者模式

口诀："分步组装复杂对象"
C++：Director控制Builder步骤

class CarBuilder {
public:
    void buildWheels() {...}
    void buildEngine() {...}
    Car getResult() {...}
};

原型模式

口诀："克隆代替new"
C++：实现clone()方法

class Prototype {
public:
    virtual Prototype* clone() const = 0;
};

二、结构型模式（7种）

适配器模式

口诀："转接头兼容接口"
C++：继承或组合目标类

class LegacyAdapter : public NewInterface {
    LegacyComponent legacy;
public:
    void newMethod() override { legacy.oldMethod(); }
};

桥接模式

口诀："抽象与实现解耦"
C++：抽象类持有实现类指针

class Window {
    WindowImpl* impl;
public:
    void draw() { impl->drawWindow(); }
};

组合模式

口诀："树形结构统一处理"
C++：组件接口统一leaf和composite

class Component {
public:
    virtual void add(Component*) {}
    virtual void operation() = 0;
};

装饰器模式

口诀："动态套娃增强功能"
C++：继承+组合

class Decorator : public Component {
    Component* wrapped;
public:
    void operation() override { 
        wrapped->operation(); 
        addedBehavior(); 
    }
};

外观模式

口诀："一键调用子系统"
C++：封装复杂子系统调用

class Facade {
    SubSystemA a;
    SubSystemB b;
public:
    void simpleAPI() { a.init(); b.start(); }
};

享元模式

口诀："共享细粒度对象"
C++：对象池 + 状态分离

class Flyweight {
    static std::map<string, Flyweight*> pool;
public:
    static Flyweight* get(const string& key) {...}
};

代理模式

口诀："中介控制访问"
C++：实现相同接口 + 控制访问

class Proxy : public Subject {
    RealSubject* real;
public:
    void request() override {
        if (checkAccess()) real->request();
    }
};

三、行为型模式（11种）

责任链模式

口诀："传递请求直到被处理"
C++：链表处理器

class Handler {
    Handler* next;
public:
    void handle(Request req) {
        if (canHandle(req)) process(req);
        else if (next) next->handle(req);
    }
};

命令模式

口诀："请求封装成对象"
C++：命令接口 + undo()

class Command {
public:
    virtual void execute() = 0;
    virtual void undo() = 0;
};

解释器模式

口诀："自定义语法解析"
C++：抽象语法树

class Expression {
public:
    virtual int interpret(Context&) = 0;
};

迭代器模式

口诀："统一遍历集合"
C++：实现begin()/end()

class Iterator {
public:
    virtual T next() = 0;
    virtual bool hasNext() = 0;
};

中介者模式

口诀："群聊代替私聊"
C++：集中事件调度

class Mediator {
public:
    virtual void notify(Component*, string) = 0;
};

备忘录模式
- 口诀："对象状态快照"
- C++：分离Originator和Memento
```
class Memento {
    friend class Originator;
    State state;
};
```

观察者模式

口诀："订阅-通知机制"
C++：Subject维护Observer列表

class Subject {
    vector<Observer*> obs;
public:
    void notify() { for (auto o : obs) o->update(); }
};

状态模式
- 口诀："对象变身术"
- C++：状态类实现相同接口
```
class State {
public:
    virtual void handle(Context&) = 0;
};
```
策略模式
- 口诀："算法即插即用"
- C++：策略接口 + 上下文
```
class Strategy {
public:
    virtual void algorithm() = 0;
};
```

模板方法模式

口诀："固定步骤，可变实现"
C++：虚函数钩子

class Framework {
    void templateMethod() {
        step1(); // 固定
        step2(); // 虚函数
    }
    virtual void step2() = 0;
};

访问者模式

口诀："双分派实现操作扩展"
C++：accept() + visit()

class Visitor {
public:
    virtual void visit(ElementA*) = 0;
    virtual void visit(ElementB*) = 0;
};

模式选择速查表

场景需求	推荐模式
需要灵活创建对象	工厂方法/抽象工厂/建造者
需要适配不同接口	适配器/桥接
需要动态添加功能	装饰器/代理
需要管理算法族	策略/状态
需要解耦调用关系	命令/观察者/中介者

黄金法则：
➤ 识别变化点 → 找到稳定抽象 → 用模式封装变化