c++设计模式

C++ 中的设计模式可以帮助开发者解决常见的编程问题，并通过组织代码来提高可维护性和可扩展性。设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。下面简要介绍这三类中的几种常见模式。

一、创建型模式

创建型模式关注对象的创建方式，确保在创建对象时不会直接实例化类，而是通过某种灵活的机制来创建对象。这种模式有助于隔离对象的创建过程，使代码更灵活。

1. 单例模式（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(); }
   };
   

   二、结构型模式

   结构型模式关注类和对象的组合，通常用于实现复杂对象结构和对象之间的关系。

2. 适配器模式（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();
       }
   };
   

   三、行为型模式

   行为型模式涉及对象之间的通信与职责的分配，着重于算法、职责和对象之间的相互作用。

3. 观察者模式（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(); }
   };
   

   这些只是常见设计模式中的一部分，使用设计模式有助于提高代码的可维护性和可扩展性，并使复杂系统中的代码更加简洁和易于理解。