探索 C++ 设计模式的常见类型和应用

C++ 是一种广泛应用于系统编程和应用软件开发的编程语言。为了提高软件的可维护性、扩展性和可重用性，设计模式（Design Patterns）在软件开发中起到了关键的作用。本文将探讨 C++ 设计模式的常见类型及其应用。

创建设计模式

创建设计模式主要用于解决“对象创建”过程中的问题，确保创建对象时采用合适的方法，避免直接实例化或频繁创建对象。常见的创建设计模式包括单例模式、工厂方法模式和建造者模式。

单例模式

单例模式（Singleton Pattern）确保一个类只有一个实例，并提供访问该实例的全局访问点。这在需要独占资源、如日志记录器或配置管理器的场景中尤为有效。

class Singleton {

private:
    static Singleton* instance;
    Singleton() {}
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};
// 静态成员变量的初始化
Singleton* Singleton::instance = nullptr;

工厂方法模式

工厂方法模式（Factory Method Pattern）定义了一个创建对象的接口，但由子类决定要实例化的具体类是哪一个。它将对象创建的过程延迟到子类中进行。

class Product {

public:
    virtual void use() = 0;
};
class ConcreteProductA : public Product {
public:
    void use() override {
        // 使用具体产品 A
    }
};
class ConcreteProductB : public Product {
public:
    void use() override {
        // 使用具体产品 B
    }
};
class Factory {
public:
    virtual Product* createProduct() = 0;
};
class FactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};
class FactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};
// 如何使用工厂方法
Factory* factory = new FactoryA();
Product* product = factory->createProduct();
product->use();

结构设计模式

结构设计模式关注类与对象的组合结构，确保每个部分协同工作，实现模块化与复用。常见的结构设计模式有适配器模式、装饰器模式和代理模式。

适配器模式

适配器模式（Adapter Pattern）使得接口不兼容的类能够一起工作。它通过将一个类的接口转换为另一个客户希望的接口来实现其目的。

class Target {

public:
    virtual void request() = 0;
};
class Adaptee {
public:
    void specificRequest() {
        // 被适配者的特定请求
    }
};
class Adapter : public Target {
private:
    Adaptee* adaptee;
public:
    Adapter(Adaptee* a) : adaptee(a) {}
    void request() override {
        adaptee->specificRequest();
    }
};

行为设计模式

行为设计模式侧重于对象之间的通信和职责分配，旨在使类与类之间的交互更加灵活。常见的行为设计模式包括观察者模式、策略模式和命令模式。

观察者模式

观察者模式（Observer Pattern）定义了对象之间的一对多依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。

class Observer {

public:
    virtual void update() = 0;
};
class ConcreteObserver : public Observer {
public:
    void update() override {
        // 更新逻辑
    }
};
class Subject {
private:
    std::vector<Observer*> observers;
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }
    void notify() {
        for (Observer* observer : observers) {
            observer->update();
    }
};
// 使用观察者模式
Subject subject;
Observer* observer = new ConcreteObserver();
subject.attach(observer);
subject.notify();

策略模式

策略模式（Strategy Pattern）定义了算法家族，并且使它们之间可以互相转换。这种模式使得算法的变化独立于其使用者。

class Strategy {

public:
    virtual void algorithmInterface() = 0;
};
class ConcreteStrategyA : public Strategy {
public:
    void algorithmInterface() override {
        // 算法A的实现
    }
};
class ConcreteStrategyB : public Strategy {
public:
    void algorithmInterface() override {
        // 算法B的实现
    }
};
class Context {
private:
    Strategy* strategy;
public:
    Context(Strategy* s) : strategy(s) {}
    void setStrategy(Strategy* s) {
        strategy = s;
    }
    void executeStrategy() {
        strategy->algorithmInterface();
    }
};
// 使用策略模式
Strategy* strategy = new ConcreteStrategyA();
Context context(strategy);
context.executeStrategy();

设计模式为软件开发提供了丰富的指导方针，帮助开发者设计出更加灵活、可复用和可维护的系统。掌握并应用这些设计模式，可以极大地提升 C++ 开发的效率和质量。