1. 创建型模式

单例模式 (Singleton)

• 意图：确保类仅有一个实例，并提供全局访问点。（常见的日志类）
• 实现：

  class Singleton {
  private:
      static Singleton* instance;
      Singleton() {} // 私有构造函数
  public:
      static Singleton* getInstance() {
          if (!instance) {
              instance = new Singleton();
          }
          return instance;
      }
      // 删除拷贝构造和赋值
      Singleton(const Singleton&) = delete;
      void operator=(const Singleton&) = delete;
  };
  Singleton* Singleton::instance = nullptr;
  

• 线程安全：需加锁（如std::mutex）或使用C++11的std::call_once。

工厂模式 (Factory)

• 简单工厂：根据参数创建不同对象。

  class Product {
  public:
      virtual void use() = 0;
  };
  class ConcreteProductA : public Product { /*...*/ };
  class Factory {
  public:
      static Product* createProduct(const std::string& type) {
          if (type == "A") return new ConcreteProductA();
          // ...
      }
  };
  

• 抽象工厂：创建相关对象族。

  class AbstractFactory {
  public:
      virtual Button* createButton() = 0;
      virtual TextBox* createTextBox() = 0;
  };
  class WinFactory : public AbstractFactory { /*...*/ };
  

---

2. 结构型模式

适配器模式 (Adapter)

• 对象适配器：持有被适配对象的实例。

  class Target {
  public:
      virtual void request() = 0;
  };
  class Adaptee { public: void specificRequest() {} };
  class Adapter : public Target {
      Adaptee* adaptee;
  public:
      Adapter(Adaptee* a) : adaptee(a) {}
      void request() override { adaptee->specificRequest(); }
  };
  

装饰器模式 (Decorator)

• 动态添加职责：

  class Component { public: virtual void operation() = 0; };
  class ConcreteComponent : public Component { /*...*/ };
  class Decorator : public Component {
      Component* component;
  public:
      Decorator(Component* c) : component(c) {}
      void operation() override { component->operation(); }
  };
  class ConcreteDecorator : public Decorator {
      void addedBehavior() { /*...*/ }
  public:
      void operation() override {
          Decorator::operation();
          addedBehavior();
      }
  };
  

---

3. 行为型模式

观察者模式 (Observer)

• 实现松散耦合：

  class Observer {
  public:
      virtual void update(const std::string& msg) = 0;
  };
  class Subject {
      std::vector<Observer*> observers;
  public:
      void attach(Observer* o) { observers.push_back(o); }
      void notify(const std::string& msg) {
          for (auto o : observers) o->update(msg);
      }
  };
  

策略模式 (Strategy)

• 运行时切换算法：

  class Strategy {
  public:
      virtual void execute() = 0;
  };
  class Context {
      Strategy* strategy;
  public:
      void setStrategy(Strategy* s) { strategy = s; }
      void execute() { strategy->execute(); }
  };
  

---

4. C++特定注意事项

• 内存管理：优先使用智能指针（std::shared_ptr, std::unique_ptr）避免泄漏。
• 多线程：单例模式需双重检查锁定或局部静态变量（C++11后线程安全）。
• 性能：虚函数可能引入开销，需权衡设计灵活性与性能。
• 模板：替代某些模式（如策略模式可通过模板在编译时绑定）。

---

总结

• 选择模式的原则：优先简单性，避免过度设计。
• 模式组合：如工厂+单例创建全局唯一对象，观察者+组合构建事件系统。
• 语言特性结合：利用RAII、模板、移动语义等增强实现。