常用的设计模式之二（行为型模式）

观察者模式

观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有观察者都会收到通知并进行相应的处理。

观察者模式包含以下几个角色：

• 抽象主题（Subject）：定义了被观察的对象接口，它可以增加和删除观察者对象，以及通知观察者对象。
• 具体主题（ConcreteSubject）：实现了抽象主题接口，它具有添加、删除观察者对象的功能。通常是被观察的对象。
• 抽象观察者（Observer）：定义了观察者接口，它具有更新数据的方法，当接收到主题通知时被调用。
• 具体观察者（ConcreteObserver）：实现了观察者接口，它保存一个指向具体主题对象的引用，实现了更新数据的方法，以便自身状态与主题状态协调。

观察者模式的核心思想是：当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知并自动更新。这种模式的优点是将观察者和被观察者解耦，使得程序的扩展性和复用性更加容易，可以动态地添加和删除观察者，从而避免了代码的臃肿和复杂性。

观察者模式在实际应用中非常常见，例如在图形界面开发中，窗口、按钮等组件就可以作为被观察者，而事件监听器就可以作为观察者。此外，观察者模式还可以用于日志记录、消息队列等领域。

下面是一个C++实现的简单观察者模式案例：

#include <iostream>
#include <vector>using namespace std;// 抽象主题类
class Subject {
public:virtual void attach(class Observer* observer) = 0;virtual void detach(class Observer* observer) = 0;virtual void notify() = 0;
};// 具体主题类
class ConcreteSubject : public Subject {
public:void attach(Observer* observer) override {observers.push_back(observer);}void detach(Observer* observer) override {for (auto it = observers.begin(); it != observers.end(); ++it) {if (*it == observer) {observers.erase(it);break;}}}void notify() override {for (auto observer : observers) {observer->update();}}void setState(int state) {this->state = state;notify();}int getState() const {return state;}private:vector<Observer*> observers;int state;
};// 抽象观察者类
class Observer {
public:virtual void update() = 0;
};// 具体观察者类
class ConcreteObserver : public Observer {
public:ConcreteObserver(ConcreteSubject* subject) : subject(subject) {subject->attach(this);}~ConcreteObserver() override {subject->detach(this);}void update() override {cout << "Observer received notification: " << subject->getState() << endl;}private:ConcreteSubject* subject;
};int main() {ConcreteSubject subject;// 添加两个观察者ConcreteObserver observer1(&subject);ConcreteObserver observer2(&subject);// 改变主题状态，触发通知subject.setState(1);// 移除一个观察者subject.detach(&observer2);// 再次改变主题状态，触发通知subject.setState(2);return 0;
}

这个示例中，Subject 定义了主题类的接口，包括添加、删除观察者和通知观察者的方法, ConcreteSubject 继承了 Subject，并实现了具体的主题类，其中 setState 方法改变主题的状态，并调用 notify 方法通知所有观察者；Observer 定义了观察者类的接口，包括更新数据的方法; ConcreteObserver 继承了 Observer，并实现了具体的观察者类，它保存了一个指ConcreteSubject 的引用，当 ConcreteSubject 的状态发生改变时，会自动更新。

在 main 函数中，我们创建了一个 ConcreteSubject 对象，并添加了两个观察者，然后改变主题状态，触发通知。接着，我们移除了一个观察者，并再次改变主题状态，验证只有一个观察者收到了通知。

模板模式

模板模式（Template Pattern）是一种行为设计模式，它定义了一个算法的骨架，而将某些步骤延迟到子类中实现。模板模式使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

模板模式的核心思想是定义一个抽象基类，其中包含了一些算法的共性，以及一些抽象方法，这些抽象方法会在具体子类中实现。然后定义一个模板方法，其中包含了一个算法的骨架，它通过调用基类中的方法来实现算法的各个步骤。具体子类可以通过重写基类中的抽象方法来实现算法的个性化定制。

以下是一个简单的 C++ 实现示例：

#include <iostream>using namespace std;// 抽象类
class AbstractClass {
public:virtual void primitiveOperation1() = 0;virtual void primitiveOperation2() = 0;void templateMethod() {primitiveOperation1();primitiveOperation2();}
};// 具体类A
class ConcreteClassA : public AbstractClass {
public:void primitiveOperation1() override {cout << "ConcreteClassA::primitiveOperation1()" << endl;}void primitiveOperation2() override {cout << "ConcreteClassA::primitiveOperation2()" << endl;}
};// 具体类B
class ConcreteClassB : public AbstractClass {
public:void primitiveOperation1() override {cout << "ConcreteClassB::primitiveOperation1()" << endl;}void primitiveOperation2() override {cout << "ConcreteClassB::primitiveOperation2()" << endl;}
};int main() {AbstractClass* a = new ConcreteClassA;a->templateMethod();AbstractClass* b = new ConcreteClassB;b->templateMethod();return 0;
}

在这个示例中，AbstractClass 是抽象基类，其中包含了一个模板方法 templateMethod，它通过调用两个抽象方法 primitiveOperation1 和 primitiveOperation2 实现算法的骨架。ConcreteClassA 和 ConcreteClassB 继承自 AbstractClass，并分别实现了自己的具体算法，即实现 primitiveOperation1 和 primitiveOperation2。

在 main 函数中，我们先创建了一个 ConcreteClassA 对象，并调用了其 templateMethod 方法，它的具体算法是先执行 primitiveOperation1，然后执行 primitiveOperation2。接着，我们创建了一个 ConcreteClassB 对象，同样调用了其 templateMethod 方法，其具体算法和 ConcreteClassA 有所不同。

模板模式的优点在于它使得算法的框架和具体实现分离，降低了实现算法的难度和维护成本，并且可以在不改变算法结构的情况下，方便地扩展和修改算法的具体实现。模板模式还可以提高代码的复用性，避免了代码重复。

模板模式的缺点在于它需要定义抽象类和具体类，这样就增加了代码的复杂度和阅读难度。此外，模板模式还可能导致类的层次结构变得更加复杂，需要进行仔细的设计。

总的来说，模板模式适用于需要实现一些具体算法，但是算法中的某些步骤可能存在差异，需要在子类中进行定制的情况。它可以让代码更加简洁，易于维护，同时提高代码的复用性和扩展性。