C++ 程序设计：四大模式（工厂+装饰+策略+观察者）

**C++ 程序设计：四大模式**

在软件开发中，设计模式是一种通用的解决方案，帮助程序员解决特定问题或实现特定的功能。四大模式，即工厂模式、装饰模式、策略模式和观察者模式，是 C++ 中非常常见的设计模式。

###1. 工厂模式**定义**

工厂模式是一种创建对象的方式，通过一个工厂类来创建多种类型的对象，而不是直接在客户端代码中创建对象。这种模式可以帮助我们解耦对象的创建过程和使用过程，使得系统更加灵活和易于维护。

**结构**

* **Product**:这是一个接口或抽象类，定义了需要被工厂创建的对象的公共方法。
* **ConcreteProduct**:这是具体的产品类，实现了 Product 接口或继承了 Product 抽象类。
* **Factory**:这是一个工厂类，负责创建 Product 对象。

**示例代码**

cpp// Product.hclass Product {
public:
 virtual void show() =0;
};

// ConcreteProduct1.hclass ConcreteProduct1 : public Product {
public:
 void show() override {
 std::cout << "ConcreteProduct1" << std::endl;
 }
};

// ConcreteProduct2.hclass ConcreteProduct2 : public Product {
public:
 void show() override {
 std::cout << "ConcreteProduct2" << std::endl;
 }
};

// Factory.hclass Factory {
public:
 static Product* createProduct(int type) {
 if (type ==1) {
 return new ConcreteProduct1();
 } else if (type ==2) {
 return new ConcreteProduct2();
 } else {
 return nullptr;
 }
 }
};

// Client.hclass Client {
public:
 void show() {
 Product* product = Factory::createProduct(1);
 product->show();
 delete product;

 product = Factory::createProduct(2);
 product->show();
 delete product;
 }
};

###2. 装饰模式**定义**

装饰模式是一种动态地给对象添加一些额外的职责或功能，而不改变其原有的类结构。这种模式可以帮助我们在不修改原有类的情况下，增加新的行为或功能。

**结构**

* **Component**:这是一个接口或抽象类，定义了需要被装饰的对象的公共方法。
* **ConcreteComponent**:这是具体的组件类，实现了 Component 接口或继承了 Component 抽象类。
* **Decorator**:这是一个装饰类，负责给 ConcreteComponent 添加额外的职责或功能。

**示例代码**

cpp// Component.hclass Component {
public:
 virtual void show() =0;
};

// ConcreteComponent.hclass ConcreteComponent : public Component {
public:
 void show() override {
 std::cout << "ConcreteComponent" << std::endl;
 }
};

// Decorator.hclass Decorator : public Component {
protected:
 Component* component;

public:
 Decorator(Component* component) : component(component) {}

 virtual ~Decorator() {
 delete component;
 }

 void show() override {
 component->show();
 }
};

// ConcreteDecorator1.hclass ConcreteDecorator1 : public Decorator {
public:
 ConcreteDecorator1(Component* component) : Decorator(component) {}

 void show() override {
 std::cout << "ConcreteDecorator1" << std::endl;
 Decorator::show();
 }
};

// Client.hclass Client {
public:
 void show() {
 Component* component = new ConcreteComponent();
 component->show();

 delete component;

 component = new ConcreteDecorator1(component);
 component->show();
 delete component;
 }
};

###3. 策略模式**定义**

策略模式是一种定义一系列算法或行为，并将这些算法或行为封装在独立的类中，使得系统可以灵活地选择和切换不同的算法或行为。

**结构**

* **Strategy**:这是一个接口或抽象类，定义了需要被执行的策略。
* **ConcreteStrategy1**:这是具体的策略类，实现了 Strategy 接口或继承了 Strategy 抽象类。
* **ConcreteStrategy2**:这是另一个具体的策略类，实现了 Strategy 接口或继承了 Strategy 抽象类。
* **Context**:这是一个上下文类，负责执行不同的策略。

**示例代码**

cpp// Strategy.hclass Strategy {
public:
 virtual void execute() =0;
};

// ConcreteStrategy1.hclass ConcreteStrategy1 : public Strategy {
public:
 void execute() override {
 std::cout << "ConcreteStrategy1" << std::endl;
 }
};

// ConcreteStrategy2.hclass ConcreteStrategy2 : public Strategy {
public:
 void execute() override {
 std::cout << "ConcreteStrategy2" << std::endl;
 }
};

// Context.hclass Context {
private:
 Strategy* strategy;

public:
 Context(Strategy* strategy) : strategy(strategy) {}

 ~Context() {
 delete strategy;
 }

 void execute() {
 strategy->execute();
 }
};

// Client.hclass Client {
public:
 void show() {
 Context context(new ConcreteStrategy1());
 context.execute();

 delete context;

 context = new Context(new ConcreteStrategy2());
 context->execute();
 delete context;
 }
};

###4. 观察者模式**定义**

观察者模式是一种允许一个对象（被观察者）在状态变化时通知其他对象（观察者）的设计模式。

**结构**

* **Subject**:这是一个被观察者类，负责维护观察者的列表和通知观察者。
* **Observer**:这是一个观察者接口或抽象类，定义了需要被通知的方法。
* **ConcreteObserver1**:这是具体的观察者类，实现了 Observer 接口或继承了 Observer 抽象类。
* **ConcreteObserver2**:这是另一个具体的观察者类，实现了 Observer 接口或继承了 Observer 抽象类。

**示例代码**

cpp// Subject.hclass Subject {
private:
 std::vector observers;

public:
 void attach(Observer* observer) {
 observers.push_back(observer);
 }

 void detach(Observer* observer) {
 for (auto it = observers.begin(); it != observers.end();) {
 if (*it == observer) {
 it = observers.erase(it);
 } else {
 ++it;
 }
 }
 }

 void notify() {
 for (const auto& observer : observers) {
 observer->update();
 }
 }
};

// Observer.hclass Observer {
public:
 virtual void update() =0;
};

// ConcreteObserver1.hclass ConcreteObserver1 : public Observer {
public:
 void update() override {
 std::cout << "ConcreteObserver1" << std::endl;
 }
};

// ConcreteObserver2.hclass ConcreteObserver2 : public Observer {
public:
 void update() override {
 std::cout << "ConcreteObserver2" << std::endl;
 }
};

// Client.hclass Client {
public:
 void show() {
 Subject subject;

 subject.attach(new ConcreteObserver1());
 subject.attach(new ConcreteObserver2());

 subject.notify();

 subject.detach(new ConcreteObserver1());

 subject.notify();
 }
};

以上就是 C++ 中四大模式的示例代码和解释。这些模式可以帮助你设计出更灵活、易于维护和扩展的系统。