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 { std::cout << "Using Product A" << std::endl; } };class ConcreteProductB : public Product { public:void use() override { std::cout << "Using Product B" << std::endl; } };class Creator { public:virtual Product *createProduct() = 0; };class ConcreteCreatorA : public Creator { public:Product *createProduct() override { return new ConcreteProductA(); } };class ConcreteCreatorB : public Creator { public:Product *createProduct() override { return new ConcreteProductB(); } };抽象工厂模式（Abstract Factory Pattern）
提供一个创建一系列相关或依赖对象的接口，而无需指定它们的具体类。示例代码：
class AbstractProductA { public:virtual void use() = 0; };class AbstractProductB { public:virtual void interact(AbstractProductA *productA) = 0; };class ConcreteProductA1 : public AbstractProductA { public:void use() override { std::cout << "Using Product A1" << std::endl; } };class ConcreteProductB1 : public AbstractProductB { public:void interact(AbstractProductA *productA) override{std::cout << "B1 interacting with ";productA->use();} };class AbstractFactory { public:virtual AbstractProductA *createProductA() = 0;virtual AbstractProductB *createProductB() = 0; };class ConcreteFactory1 : public AbstractFactory { public:AbstractProductA *createProductA() override { return new ConcreteProductA1(); }AbstractProductB *createProductB() override { return new ConcreteProductB1(); } };二、结构型模式
结构型模式关注类和对象的组合，通常用于实现复杂对象结构和对象之间的关系。
-
适配器模式（Adapter Pattern）
将一个类的接口转换为客户希望的另一个接口，适配器模式使得原本接口不兼容的类可以一起工作。示例代码：
class Target { public:virtual void request() { std::cout << "Target request" << std::endl; } };class Adaptee { public:void specificRequest() { std::cout << "Adaptee specific request" << std::endl; } };class Adapter : public Target { private:Adaptee *adaptee;public:Adapter(Adaptee *adaptee) : adaptee(adaptee) {}void request() override { adaptee->specificRequest(); } };装饰者模式（Decorator Pattern）
动态地给对象增加功能，通过组合对象来实现，避免了继承的使用。示例代码：
class Component { public:virtual void operation() = 0; };class ConcreteComponent : public Component { public:void operation() override { std::cout << "Concrete Component operation" << std::endl; } };class Decorator : public Component { protected:Component *component;public:Decorator(Component *component) : component(component) {}void operation() override { component->operation(); } };class ConcreteDecoratorA : public Decorator { public:ConcreteDecoratorA(Component *component) : Decorator(component) {}void operation() override{Decorator::operation();std::cout << "Concrete Decorator A operation" << std::endl;} };外观模式（Facade Pattern）
为子系统中的一组接口提供一个一致的接口，外观模式定义了一个高层接口，使得子系统更易使用。示例代码：
class SubsystemA { public:void operationA() { std::cout << "Subsystem A operation" << std::endl; } };class SubsystemB { public:void operationB() { std::cout << "Subsystem B operation" << std::endl; } };class Facade { private:SubsystemA *subsystemA;SubsystemB *subsystemB;public:Facade(){subsystemA = new SubsystemA();subsystemB = new SubsystemB();}void operation(){subsystemA->operationA();subsystemB->operationB();} };三、行为型模式
行为型模式涉及对象之间的通信与职责的分配，着重于算法、职责和对象之间的相互作用。
-
观察者模式（Observer Pattern）
定义对象间的一对多依赖，当一个对象改变状态时，所有依赖它的对象都会收到通知并自动更新。示例代码：
class Observer { public:virtual void update() = 0; };class Subject { private:std::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 { std::cout << "Observer updated" << std::endl; } };策略模式（Strategy Pattern）
定义一组算法，将每个算法封装起来，并使它们可以互换。示例代码：
class Strategy { public:virtual void execute() = 0; };class ConcreteStrategyA : public Strategy { public:void execute() override { std::cout << "Strategy A executed" << std::endl; } };class ConcreteStrategyB : public Strategy { public:void execute() override { std::cout << "Strategy B executed" << std::endl; } };class Context { private:Strategy *strategy;public:void setStrategy(Strategy *strategy) { this->strategy = strategy; }void executeStrategy() { strategy->execute(); } };这些只是常见设计模式中的一部分，使用设计模式有助于提高代码的可维护性和可扩展性，并使复杂系统中的代码更加简洁和易于理解。
