C++筹划模式（观察者模式）

观察者模式是一种软件筹划模式。
一、界说与概念

        在观察者模式中，存在被观察的对象（主题）和观察这个对象的观察者。主题在自身状态发生厘革时，会关照全部注册的观察者，让它们可以或许做出相应的反应。
二、作用与上风

• 1. 解耦：主题和观察者之间的依靠关系被弱化，它们之间通过抽象接口举行交互，使得两边的厘革不会直接影响到对方，进步了体系的可维护性和可扩展性。
  
• 2. 机动性：可以在运行时动态地添加、删除观察者，方便体系的扩展和维护。
  
• 3. 进步相应性：当主题状态发生厘革时，可以或许及时关照全部观察者，使得体系可以或许快速做出反应。
  

三、应用场景

• 1. 图形用户界面：比方按钮的点击变乱可以被多个组件观察，当按钮被点击时，这些组件可以做出相应的反应。
  
• 2. 消息关照体系：当有新消息时，关照全部订阅了该消息的用户。
  
• 3. 股票生意业务体系：股票代价厘革时，关照全部关注该股票的投资者。
  

四、代码实现

        观察者模式重要涉及到两个脚色：观察者（Observer）和被观察对象（Subject）。以下是观察者模式的类图形貌：
一、被观察对象（Subject）

属性：

• 通常有一个或多个观察者列表，用于存储注册的观察者对象。
  

方法：

• attach(Observer observer)：用于将观察者添加到观察者列表中。
  
• detach(Observer observer)：从观察者列表中移除指定的观察者。
  
• notifyObservers()：当被观察对象的状态发生厘革时，关照全部注册的观察者。
  

二、观察者（Observer）

• 方法：

• update()：当被观察对象状态厘革时，被观察对象会调用此方法关照观察者，观察者在这个方法中举行相应的处置惩罚。
  

        观察者模式通过这种方式实现了对象之间的一对多依靠关系，当被观察对象的状态发生厘革时，全部依靠它的观察者都会收到关照并举行相应的更新。
 以下是用 C++实现观察者模式的示例代码：

2. #include <iostream>
3. #include <vector>
4. #include <algorithm>
6. // 抽象观察者类
7. class Observer {
8. public:
9.     virtual void update() = 0;
10. };
12. // 抽象主题类
13. class Subject {
14. public:
15.     virtual void attach(Observer* observer) = 0;
16.     virtual void detach(Observer* observer) = 0;
17.     virtual void notify() = 0;
18. };
20. // 具体主题类
21. class ConcreteSubject : public Subject {
22. private:
23.     int state;
24.     std::vector<Observer*> observers;
25. public:
26.     ConcreteSubject() : state(0) {}
28.     void setState(int newState) {
29.         state = newState;
30.         notify();
31.     }
33.     int getState() const {
34.         return state;
35.     }
37.     void attach(Observer* observer) override {
38.         observers.push_back(observer);
39.     }
41.     void detach(Observer* observer) override {
42.         observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
43.     }
45.     void notify() override {
46.         for (Observer* observer : observers) {
47.             observer->update();
48.         }
49.     }
50. };
52. // 具体观察者类
53. class ConcreteObserver : public Observer {
54. private:
55.     ConcreteSubject* subject;
56. public:
57.     ConcreteObserver(ConcreteSubject* sub) : subject(sub) {
58.         subject->attach(this);
59.     }
61.     void update() override {
62.         int state = subject->getState();
63.         std::cout << "Observer notified. New state: " << state << std::endl;
64.     }
65. };
67. int main() {
68.     ConcreteSubject* subject = new ConcreteSubject();
69.     ConcreteObserver* observer1 = new ConcreteObserver(subject);
70.     ConcreteObserver* observer2 = new ConcreteObserver(subject);
72.     subject->setState(10);
73.     subject->setState(20);
75.     delete observer2;
76.     subject->setState(30);
78.     delete observer1;
79.     delete subject;
81.     return 0;
82. }

复制代码

在这个示例中，Subject是抽象主题类，ConcreteSubject是详细主题类，Observer是抽象观察者类，ConcreteObserver是详细观察者类。详细主题的状态厘革时会关照全部注册的观察者。