【设计模式】GOF概括

一、创建型模式（5种）

1. 单例模式 (Singleton)

• 适用场景：全局唯一实例（如配置管理、日志工具）。
• C++示例：

  // 所谓的scott mayer单例模式
  class Singleton {
  public:
      static Singleton& getInstance() {
          static Singleton instance; // C++11线程安全
          return instance;
      }
      void doSomething() {}
  private:
      Singleton() {} // 私有构造函数
      Singleton(const Singleton&) = delete;
      Singleton& operator=(const Singleton&) = delete;
  };
  

2. 工厂方法模式 (Factory Method)

• 适用场景：由子类决定实例化的具体类（如跨平台UI组件）。
• C++示例：

  class Document {
  public: virtual void open() = 0;
  };
  class TextDoc : public Document {
  public: void open() override { /* 打开文本文件 */ }
  };
  
  class Application {
  public:
      virtual unique_ptr<Document> createDoc() = 0;
      void newDoc() { auto doc = createDoc(); doc->open(); }
  };
  class TextApp : public Application {
  public: unique_ptr<Document> createDoc() override { return make_unique<TextDoc>(); }
  };
  

3. 抽象工厂模式 (Abstract Factory)

• 适用场景：创建多个产品族的对象（如跨风格UI控件）。
• C++示例：

  class Button { public: virtual void render() = 0; };
  class WinButton : public Button { void render() override { /* Windows样式 */ } };
  
  class GUIFactory {
  public:
      virtual unique_ptr<Button> createButton() = 0;
  };
  class WinFactory : public GUIFactory {
  public: unique_ptr<Button> createButton() override { return make_unique<WinButton>(); }
  };
  

4. 建造者模式 (Builder)

• 适用场景：分步构建复杂对象（如生成不同格式的文档）。
• C++示例：

  class Pizza {
  public: string dough, sauce, topping;
  };
  class PizzaBuilder {
  protected: Pizza pizza;
  public:
      virtual void buildDough() = 0;
      virtual void buildSauce() = 0;
      Pizza getPizza() { return pizza; }
  };
  class HawaiianBuilder : public PizzaBuilder {
  public:
      void buildDough() override { pizza.dough = "厚"; }
      void buildSauce() override { pizza.sauce = "番茄"; }
  };
  

5. 原型模式 (Prototype)

• 适用场景：通过复制已有对象创建新对象（如游戏中的敌人克隆）。
• C++示例：

  class Enemy {
  public:
      virtual unique_ptr<Enemy> clone() = 0;
      virtual ~Enemy() = default;
  };
  class Dragon : public Enemy {
  public: unique_ptr<Enemy> clone() override { return make_unique<Dragon>(*this); }
  };
  

---

二、结构型模式（7种）

6. 适配器模式 (Adapter)

• 适用场景：接口不兼容时转换接口（如旧系统集成）。
• C++示例：

  class LegacyPrinter {
  public: void printDocument() { /* 旧接口 */ }
  };
  class Printer {
  public: virtual void print() = 0;
  };
  class PrinterAdapter : public Printer {
      LegacyPrinter legacyPrinter;
  public: void print() override { legacyPrinter.printDocument(); }
  };
  

7. 桥接模式 (Bridge)

• 适用场景：分离抽象与实现（如跨平台图形渲染）。
• C++示例：

  class Renderer {
  public: virtual void renderCircle(float radius) = 0;
  };
  class OpenGLRenderer : public Renderer {
  public: void renderCircle(float r) override { /* OpenGL实现 */ }
  };
  class Shape {
      Renderer* renderer;
  public:
      Shape(Renderer* r) : renderer(r) {}
      virtual void draw() = 0;
  };
  class Circle : public Shape { /* 调用renderer->renderCircle */ };
  

8. 组合模式 (Composite)

• 适用场景：树形结构处理（如文件系统）。
• C++示例：

  class FileSystemComponent {
  public: virtual void ls() = 0;
  };
  class File : public FileSystemComponent {
  public: void ls() override { /* 显示文件 */ }
  };
  class Directory : public FileSystemComponent {
      vector<FileSystemComponent*> children;
  public: void ls() override { for (auto c : children) c->ls(); }
  };
  

9. 装饰模式 (Decorator)

• 适用场景：动态扩展对象功能（如带缓冲的流）。
• C++示例：

  class Stream {
  public: virtual void write(string data) = 0;
  };
  class FileStream : public Stream { /* 基础写操作 */ };
  class BufferedStream : public Stream {
      Stream* stream;
  public:
      BufferedStream(Stream* s) : stream(s) {}
      void write(string data) override { /* 添加缓冲逻辑 */ }
  };
  

10. 外观模式 (Facade)

• 适用场景：简化复杂子系统调用（如一键启动计算机）。
• C++示例：

  class CPU { public: void boot() {} };
  class Memory { public: void load() {} };
  class ComputerFacade {
      CPU cpu;
      Memory memory;
  public:
      void start() { cpu.boot(); memory.load(); }
  };
  

11. 享元模式 (Flyweight)

• 适用场景：共享大量细粒度对象（如文本编辑器中的字符格式）。
• C++示例：

  class FontStyle { /* 共享的字体样式数据 */ };
  class FontFactory {
      unordered_map<string, FontStyle*> pool;
  public:
      FontStyle* getFont(const string& key) { /* 返回或创建字体 */ }
  };
  

12. 代理模式 (Proxy)

• 适用场景：控制对象访问（如懒加载、权限检查）。
• C++示例：

  class Image { public: virtual void display() = 0; };
  class RealImage : public Image { /* 加载大图 */ };
  class ProxyImage : public Image {
      RealImage* realImage = nullptr;
  public: void display() override { if (!realImage) realImage = new RealImage(); realImage->display(); }
  };
  

---

三、行为型模式（11种）

13. 责任链模式 (Chain of Responsibility)

• 适用场景：多个对象处理同一请求（如日志级别过滤）。
• C++示例：

  class Handler {
      Handler* next;
  public:
      virtual void handle(int level) { if (next) next->handle(level); }
      void setNext(Handler* h) { next = h; }
  };
  class ConcreteHandler : public Handler {
      int requiredLevel;
  public: void handle(int level) override { if (level >= requiredLevel) /* 处理 */ else Handler::handle(level); }
  };
  

14. 命令模式 (Command)

• 适用场景：将请求封装为对象（如撤销操作）。
• C++示例：

  class Command {
  public: virtual void execute() = 0;
  };
  class LightOnCommand : public Command {
      Light light;
  public: void execute() override { light.on(); }
  };
  

15. 解释器模式 (Interpreter)

• 适用场景：定义语法规则（如SQL解析）。
• C++示例：略（需定义表达式树及解析逻辑）。

16. 迭代器模式 (Iterator)

• 适用场景：遍历集合元素（如自定义容器迭代）。
• C++示例：

  template<typename T>
  class Iterator {
  public: virtual T next() = 0; virtual bool hasNext() = 0;
  };
  class ArrayIterator : public Iterator<int> { /* 实现数组遍历 */ };
  

17. 中介者模式 (Mediator)

• 适用场景：减少对象间直接通信（如聊天室）。
• C++示例：

  class ChatRoom {
  public: static void sendMessage(User* user, const string& msg) { /* 转发消息 */ }
  };
  class User { void send(const string& msg) { ChatRoom::sendMessage(this, msg); } };
  

18. 备忘录模式 (Memento)

• 适用场景：保存对象状态（如撤销功能）。
• C++示例：

  class EditorMemento { string content; /* 保存状态 */ };
  class Editor {
      string content;
  public: EditorMemento save() { return EditorMemento(content); }
      void restore(const EditorMemento& m) { content = m.getContent(); }
  };
  

19. 观察者模式 (Observer)

• 适用场景：一对多依赖通知（如事件处理）。
• C++示例：

  class Observer {
  public: virtual void update(float price) = 0;
  };
  class Stock {
      vector<Observer*> observers;
  public: void addObserver(Observer* o) { observers.push_back(o); }
      void notify(float price) { for (auto o : observers) o->update(price); }
  };
  

20. 状态模式 (State)

• 适用场景：对象状态影响行为（如订单状态流转）。
• C++示例：

  class State { public: virtual void handle() = 0; };
  class ConcreteStateA : public State { void handle() override { /* 切换到StateB */ } };
  class Context {
      State* state;
  public: void setState(State* s) { state = s; } void request() { state->handle(); }
  };
  

21. 策略模式 (Strategy)

• 适用场景：动态切换算法（如排序策略）。
• C++示例：

  class SortStrategy {
  public: virtual void sort(vector<int>& data) = 0;
  };
  class QuickSort : public SortStrategy { void sort(vector<int>& data) override { /* 快速排序 */ } };
  

22. 模板方法模式 (Template Method)

• 适用场景：固定算法骨架，子类重写步骤（如游戏循环）。
• C++示例：

  class Game {
  public:
      void play() { initialize(); start(); end(); } // 模板方法
      virtual void initialize() = 0;
      virtual void start() = 0;
      virtual void end() { /* 默认实现 */ }
  };
  

23. 访问者模式 (Visitor)

• 适用场景：为对象结构添加新操作（如AST遍历）。
• C++示例：

  class Visitor { public: virtual void visit(ElementA&) = 0; };
  class Element { public: virtual void accept(Visitor& v) = 0; };
  class ElementA : public Element { void accept(Visitor& v) override { v.visit(*this); } };
  

---

使用注意事项

• 模式选择：根据问题场景选择模式，避免过度设计。
• C++注意事项：使用智能指针管理资源（如unique_ptr），注意多态基类的虚析构函数。
• 核心目标：提升代码复用性、可扩展性和可维护性。