设计模式（c++）

设计模式通常分为三大类：

创建型模式（Creational Patterns）：负责对象创建的机制，主要解决对象创建过程中的复杂性和灵活性问题。
结构型模式（Structural Patterns）：负责处理类或对象之间的关系，简化这些关系并提高代码的可复用性和维护性。
行为型模式（Behavioral Patterns）：负责对象之间的通信和算法的行为，提供松耦合的方式进行对象间的交互。

下面对常见的设计模式做详细讲解。

创建型模式

单例模式（Singleton Pattern）
- 定义：确保一个类只有一个实例，并提供一个全局访问点。
- 适用场景：需要控制某个类的实例化次数，例如配置管理类、日志记录类。
- 实现方式：通过私有化构造函数，提供一个静态方法获取唯一的实例。
```
class Singleton {
private:static Singleton* instance;Singleton() {}  // 私有化构造函数
public:static Singleton* getInstance() {if (instance == nullptr) {instance = new Singleton();}return instance;}
};
```

工厂模式（Factory Pattern）

定义：定义一个接口用于创建对象，但让子类决定实例化哪个类。
适用场景：对象创建逻辑复杂，需要多种类型对象时。
实现方式：将对象的创建逻辑封装在工厂类中。

class Product {
public:virtual void use() = 0;
};

class ConcreteProductA : public Product {
public:void use() override { cout << "使用产品A" << endl; }
};

class ConcreteProductB : public Product {
public:void use() override { cout << "使用产品B" << endl; }
};

class Factory {
public:static Product* createProduct(char type) {if (type == 'A') return new ConcreteProductA();if (type == 'B') return new ConcreteProductB();return nullptr;}
};

抽象工厂模式（Abstract Factory Pattern）

定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体的类。
适用场景：需要生产一系列相关产品时（如 UI 组件库）。
实现方式：通过工厂类创建多个产品家族。

class Button {
public:virtual void render() = 0;
};

class MacButton : public Button {
public:void render() override { cout << "Mac按钮" << endl; }
};

class WindowsButton : public Button {
public:void render() override { cout << "Windows按钮" << endl; }
};

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

class MacFactory : public GUIFactory {
public:Button* createButton() override { return new MacButton(); }
};

class WindowsFactory : public GUIFactory {
public:Button* createButton() override { return new WindowsButton(); }
};

结构型模式

适配器模式（Adapter Pattern）
- 定义：将一个类的接口转换为客户希望的另一个接口，适配器模式使得原本接口不兼容的类可以协同工作。
- 适用场景：需要整合现有类的功能，但接口不一致时。
- 实现方式：定义一个适配器类，继承或组合需要适配的类，并实现目标接口。
```
class Target {
public:virtual void request() = 0;
};

class Adaptee {
public:void specificRequest() { cout << "特殊请求" << endl; }
};

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

代理模式（Proxy Pattern）

定义：为另一个对象提供一种代理，以控制对该对象的访问。
适用场景：需要控制或延迟访问某个对象时（如远程代理、虚拟代理）。
实现方式：代理类持有被代理类的实例，并控制访问。

class Subject {
public:virtual void request() = 0;
};

class RealSubject : public Subject {
public:void request() override { cout << "真实请求" << endl; }
};

class Proxy : public Subject {
private:RealSubject* realSubject;
public:void request() override {if (!realSubject) realSubject = new RealSubject();realSubject->request();}
};

装饰者模式（Decorator Pattern）

定义：动态地给对象添加额外的功能。
适用场景：需要在不改变类定义的情况下增强对象功能时。
实现方式：通过组合对象，将装饰功能附加到被装饰对象上。

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

class ConcreteComponent : public Component {
public:void operation() override { cout << "基本操作" << endl; }
};

class Decorator : public Component {
protected:Component* component;
public:Decorator(Component* c) : component(c) {}void operation() override { component->operation(); }
};

class ConcreteDecorator : public Decorator {
public:ConcreteDecorator(Component* c) : Decorator(c) {}void operation() override {Decorator::operation();cout << "附加操作" << endl;}
};

行为型模式

观察者模式（Observer Pattern）
- 定义：定义对象间的一对多依赖，当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。
- 适用场景：当一个对象的状态变化需要通知多个对象时（如事件系统）。
- 实现方式：定义主题和观察者接口，主题保存观察者列表，并在状态改变时通知它们。
```
class Observer {
public:virtual void update() = 0;
};

class Subject {
private:vector<Observer*> observers;
public:void attach(Observer* observer) { observers.push_back(observer); }void notify() {for (auto* observer : observers) {observer->update();}}
};

class ConcreteObserver : public Observer {
public:void update() override { cout << "收到更新通知" << endl; }
};
```

状态模式（State Pattern）

定义：允许对象在内部状态发生改变时改变其行为，对象看起来像是改变了其类。
适用场景：对象的行为依赖于状态，并且状态之间可以相互转换时（如状态机、交易状态）。
实现方式：将不同的状态封装成独立的类，通过状态类处理相应的逻辑。

class State {
public:virtual void handle() = 0;
};

class ConcreteStateA : public State {
public:void handle() override { cout << "处理状态A" << endl; }
};

class ConcreteStateB : public State {
public:void handle() override { cout << "处理状态B" << endl; }
};

class Context {
private:State* state;
public:Context(State* s) : state(s) {}void setState(State* s) { state = s; }void request() { state->handle(); }
};