观察者模式

观察者模式

观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都要得到通知并自动更新。

观察者模式从根本上讲必须包含两个角色：观察者和被观察对象。

被观察对象自身应该包含一个容器来存放观察者对象，当被观察者自身发生改变时通知容器内所有的观察者对象自动更新。

观察者对象可以注册到被观察者的中，完成注册后可以检测被观察者的变化，接收被观察者的通知。当然观察者也可以被注销掉，停止对被观察者的监控

实现：实现观察者模式：抽象观察者，抽象被观察者，具体观察者，具体被观察者

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

class Observe;

//被观察者抽象类
class Subject
{
public:
    virtual ~Subject() {}
    virtual void Add(Observe* ob) = 0;
    virtual void Remove(Observe* ob) = 0;
    virtual void Notify() = 0;
};
//观察者抽象类
class Observe
{
public:
    virtual ~Observe() {}
    virtual void Update() = 0;
    virtual void SetName(const string& _name) = 0;
    virtual const string& GetName() = 0;
};

//具体被观察者类
class MySubject :public Subject
{
private:
	//list里面的元素是指向Observe对象的智能指针，详见CPP智能指针
    list<shared_ptr<Observe>> observeList;
public:
    ~MySubject()
    {
        observeList.clear();
    }

    virtual void Add(Observe* ob) override
    {
        shared_ptr<Observe> temp(ob);
        auto iter = find(observeList.begin(), observeList.end(), temp);
        if (iter == observeList.end())
        {
            observeList.push_front(temp);
        }
        else
        {
            cout << "Observe already exists" << endl;
        }
    }

    virtual void Remove(Observe* ob) override
    {
        auto iter = observeList.begin();
        for (; iter != observeList.end(); ++iter)
        {
            if (iter->get() == ob)
            {
                observeList.erase(iter);
                cout << "remove observe" << endl;
                return;
            }
        }
    }

    virtual void Notify() override
    {
        auto iter = observeList.begin();
        for (; iter != observeList.end(); ++iter)
        {
            iter->get()->Update();
        }
    }
};

//具体观察者类
class ObKing :public Observe
{
private:
    string name;
public:
    ObKing():name("ObKing of unknow") {}
    ObKing(const string& _name) :name(_name) {}
    ~ObKing() { cout << name << "被析构了" << endl; }
    virtual void Update() override
    {
        cout << name << "Update" << endl;
    }
    virtual void SetName(const string& _name) override
    {
        name = _name;
    }
    virtual const string& GetName() override
    {
        return name;
    }
};


int main()
{
    ObKing* ob1 = new ObKing();
    ObKing* ob2 = new ObKing("HuNan ObKing");
    ObKing* ob3 = new ObKing("GuangDong ObKing");
    ObKing* ob4 = new ObKing("ZheJiang ObKing");

    MySubject* mySubject = new MySubject();
    mySubject->Add(ob1);
    mySubject->Add(ob2);
    mySubject->Add(ob3);
    mySubject->Add(ob4);

    mySubject->Notify();

    cout << endl;
    mySubject->Remove(ob1);
    mySubject->Notify();

    cout << endl;
    
     //为什么只delete容器是因为MySubject类中的容器元素是智能指针，
     //shared_ptr类型的智能指针在引用计数归0后，自动销毁该对象。
     //详见CPP智能指针
    delete mySubject;
    mySubject = nullptr;
    
    return 0;
}

运行结果如下：