设计模式-观察者模式

观察者模式

        定义了一种一对多的关系，让多个观察者对象同时监听一个被观察对象。被观察对象状态发生变化时，会通知所有的观察对象，让他们更新自己的状态。

两种角色

观察者：内部包含了被观察者对象，当被观察者对象状态发生变化时，更新自己的状态

被观察者：内部包含了所有观察者对象，当状态发生变化时，通知所有观察者更新自己的状态

观察者模式的抽象模型有两个方面，其中一方面依赖于另一方面，这是可以用观察者模式将这两者封装在独立的对象中，使他们各自独立的改变和复用

代码如下

#include <iostream>
#include <string>
#include <list>
using namespace std;

class Subject;//被观察者

//观察者 基类 内部实例化了被观察者对象
class Observer{
protected:
    string name;
    Subject *sub;

public:
    Observer(string name,Subject *sub){
        this->name = name;
        this->sub = sub;
    }
    
    virtual void update() = 0;//纯虚函数，需要子类实现 用于更新观察者
};

//观察者 具体类
class StockObserver : public Observer{
public:
    StockObserver(string name,Subject *sub) : Observer(name,sub){};
    void update(){
        cout << name << "收到消息：" << sub->action << endl;
    }
};

//观察者 具体类
class NBAObserver: public Observer{
public:
    NBAObserver(string name,Subject *sub) : Observer(name,sub){};
    void update(){
        cout << name << "收到消息：" << sub->action << endl;
    }
};

//被观察者 基类 内部存放所有观察者对象，以便状态发生变化时，通知所有观察者
class Subject{
protocted:
    list<Observer *> observers;//存放的是父类指针

public:
    string action; //被观察者对象的状态，状态改变要通知观察者
    virtual void attach(Observer *) = 0; //加入一个观察者
    virtual void detach(Observer *) = 0; //删除一个观察者
    virtual void notify() = 0;
};

//被观察者 具体类
class Secretary : public Subject{
    void attach(Observer *observer){
        observers.push_back(observer);
    }
    
    void detach(Observer *observer){
        auto iter = observers.begin();
        while(iter != observers.end()){
            if((*iter) == observer){
                observers.erase(iter);
                return;
            }
            ++iter;
        }
    }

    void notify(){
        auto iter = observers.begin();
        while(iter != observers.end()){
            (*iter)->update();
            iter++;
        }
    }
};

int main()
{
    //测试

    return 0;
}