常用设计模式-观察者模式

         观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。它还有两个别名，依赖(Dependents)，发布-订阅(Publish-Subsrcibe)

        当观察者观察到事件到来之后，通知对该事件感兴趣的监听者进行相应的操作

        抽象主题/抽象被观察者(Subject)：将所有观察者对象保存在一个集合中，可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象
        具体主题/具体被观察者(ConcreteSubject)：该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知
        抽象观察者(Observer)：它定义了一个更新接口，使得在得到主题/被观察者更新时通知自己
        具体观察者(ConcrereObserver)：实现抽象观察者定义的更新接口，以便在得到主题/被观察者更新时通知自己更新自身状态

//抽象Observer-抽象英雄
class AbstractHero {
public:
    virtual void updata() = 0;
};

//具体Observer-具体英雄A
class HeroA:public AbstractHero {
public:
    HeroA() {
        cout << "英雄A开始打Boss-------" << endl;
    }
    virtual void updata() {
        cout << "英雄A捡装备" << endl;
    }
};

//具体Observer-具体英雄B
class HeroB :public AbstractHero {
public:
    HeroB() {
        cout << "英雄B开始打Boss-------" << endl;
    }
    virtual void updata() {
        cout << "英雄B捡装备" << endl;
    }
};

//具体Observer-具体英雄C
class HeroC :public AbstractHero {
public:
    HeroC() {
        cout << "英雄C开始打Boss-------" << endl;
    }
    virtual void updata() {
        cout << "英雄C捡装备" << endl;
    }
};

//Observer目标-抽象Boss
class AbstractBoss {
public:
    //添加观察者
    virtual void addHero(AbstractHero* hero) = 0;
    //删除观察者
    virtual void deleteHero(AbstractHero* hero) = 0;
    //通知所有观察者
    virtual void notifyHero() = 0;
};

//具体观察者对象-具体BossA
class BossA: public AbstractBoss{
public:
    //添加观察者
    virtual void addHero(AbstractHero* hero) {
        pHeroList.push_back(hero);
}
    //删除观察者
    virtual void deleteHero(AbstractHero* hero) {
        pHeroList.remove(hero);
    }
    //通知所有观察者
    virtual void notifyHero() {
        for (auto &it :pHeroList) {
            it->updata();
        }
    }
public:
    list<AbstractHero*> pHeroList;
};

//Invoker
void test() {
    //创建观察者
    AbstractHero* heroA = new HeroA;
    AbstractHero* heroB = new HeroB;
    AbstractHero* heroC = new HeroC;
    
    //创建观察目标
    AbstractBoss* bossA = new BossA;
    bossA->addHero(heroA);
    bossA->addHero(heroB);
    bossA->addHero(heroC);

    cout << "英雄C阵亡"<<endl;
    bossA->deleteHero(heroC);
    cout << "BossA死亡，通知未死亡英雄，捡装备" << endl;
    bossA->notifyHero();

}

        优点：观察者和被观察者是抽象耦合的；建立了一套触发机制
        缺点：
                1.如果一个观察目标有很多观察者的话，将所有的观察者都通知到会花费很多时间
                2.如果观察者和观察目标间有循环依赖，观察目标会触发它们之间进行循环调用，可能导致系统崩溃
                3.观察者模式没有相应的机制让观察者知道观察目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化