设计模式 -- 观察者模式

观察者模式：定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则全部依赖它的对象都会获得通知并自动更新。

#include <iostream>
#include <list>

//AbstractObserver（抽象观察者）
//——为那些在目标发生改变时需得到通知的对象定义一个更新接口。
class AbstractObserver
{
public:
    virtual void update() = 0;
};

//具体观察者
//——维护一个指向具体观察对象的引用；
//——存储有关状态，这些状态应与目标的状态保持一致；
//——实现AbstractObserver的更新接口以使自身状态与目标的状态保持一致。
class Observer1 : public AbstractObserver
{
public:
    Observer1()
    {
        std::cout << "Observer1未被通知，状态不变" << std::endl;
    }
    virtual void update()
    {
        std::cout << "Observer1被通知，状态改变" << std::endl;
    }
};

class Observer2 : public AbstractObserver
{
public:
    Observer2()
    {
        std::cout << "Observer2未被通知，状态不变" << std::endl;
    }
    virtual void update()
    {
        std::cout << "Observer2被通知，状态改变" << std::endl;
    }
};

class Observer3 : public AbstractObserver
{
public:
    Observer3()
    {
        std::cout << "Observer3未被通知，状态不变" << std::endl;
    }
    virtual void update()
    {
        std::cout << "Observer3被通知，状态改变" << std::endl;
    }
};

//AbstractSubject（抽象观察目标）
//——目标知道它的观察者。能够有任意多个观察者观察同一个目标；
//——提供注册和删除观察者对象的接口。
class AbstractSubject
{
public:
    //添加观察者
    virtual void AddObserver(AbstractObserver* observer) = 0;
    //删除观察者
    virtual void DeleteObserver(AbstractObserver* observer) = 0;
    //通知全部观察者
    virtual void NotifyAllObserver() = 0;
};



//具体观察者
//——维护一个指向ConcreteSubject对象的引用；
//——存储有关状态，这些状态应与目标的状态保持一致；
//——实现Observer的更新接口以使自身状态与目标的状态保持一致。
class Subject : public AbstractSubject
{
public:
    //添加观察者
    virtual void AddObserver(AbstractObserver* observer)
    {
        ObserverList.push_back(observer);
    }
    //删除观察者
    virtual void DeleteObserver(AbstractObserver* observer)
    {
        ObserverList.remove(observer);
    }
    //通知全部观察者
    virtual void NotifyAllObserver()
    {
        for (std::list<AbstractObserver*>::iterator it = ObserverList.begin(); it != ObserverList.end(); it++)
        {
            (*it)->update();
        }
    }

    //具体观察者列表
    std::list<AbstractObserver*> ObserverList;
};


void test()
{
    //建立观察者
    AbstractObserver* observer1 = new Observer1;
    AbstractObserver* observer2 = new Observer2;
    AbstractObserver* observer3 = new Observer3;

    //建立观察目标
    AbstractSubject* subject = new Subject;

    //添加观察目标
    subject->AddObserver(observer1);
    subject->AddObserver(observer2);
    subject->AddObserver(observer3);

    std::cout << "观察者收到通知" << std::endl;
    subject->NotifyAllObserver();
}

int main()
{
    test();

    return 0;
}


//打印结果：
Observer1未被通知，状态不变
Observer2未被通知，状态不变
Observer3未被通知，状态不变
观察者收到通知
Observer1被通知，状态改变
Observer2被通知，状态改变
Observer3被通知，状态改变