当前位置：首页 > article >正文

设计模式（c++）

article 2024/10/22 4:33:19

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

创建型模式（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(); }
};