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

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

创建型模式（5种）

1. 单例模式（Singleton）

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

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

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

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

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

4. 建造者模式（Builder）

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

5. 原型模式（Prototype）

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

结构型模式（7种）

1. 适配器模式（Adapter）

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

2. 桥接模式（Bridge）

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

3. 组合模式（Composite）

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

4. 装饰器模式（Decorator）

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

5. 外观模式（Facade）

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

6. 享元模式（Flyweight）

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

7. 代理模式（Proxy）

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

行为型模式（11种）

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

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

2. 命令模式（Command）

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

3. 解释器模式（Interpreter）

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

4. 迭代器模式（Iterator）

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

5. 中介者模式（Mediator）

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

6. 备忘录模式（Memento）

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

7. 观察者模式（Observer）

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

8. 状态模式（State）

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

9. 策略模式（Strategy）

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

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

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

11. 访问者模式（Visitor）

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

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

一、创建型模式（5种）

1. 工厂方法模式

   • 口诀："子类决定生产什么"

   • 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种）

1. 适配器模式

   • 口诀："转接头兼容接口"

   • 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 pool;
  public:
      static Flyweight* get(const string& key) {...}
  };

• 代理模式

  • 口诀："中介控制访问"

  • C++：实现相同接口 + 控制访问

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

三、行为型模式（11种）

1. 责任链模式

   • 口诀："传递请求直到被处理"

   • 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 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;
  };

模式选择速查表

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

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