010 --- 第14章 观察者模式

简述：

　　观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够主动更新自己。

　　观察者模式包括：抽象主题类、具体主题类、抽象观察者类、具体观察者类。

　　　　抽象主题类：它把所有对观察者对象的指针保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。

　　　　具体主题类：具体主题，将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有登记过的观察者发出通知。

　　　　抽象观察者类：抽象观察者，为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。

　　　　具体观察者类：具体观察者，实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。

 

应用场景：需要一个标志相应所有状态的改变，主题类封装了观察者列表，主题类改变状态通知观察者，所有观察者改变自身的状态

 

注：开发环境调整为VS2017，操作系统win11

观察者模式代码：C++与C#的区别要注意相互包含的问题，同时要注意声明顺序。

 

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

// 抽象观察者类
class CObserver
{
public:
    virtual void UpDate() {}
};

// 抽象通知者类
class CSubject
{
private:
    list<CObserver*> m_listObserver;

public:
    virtual void Attach(CObserver* pObserver)
    {
        m_listObserver.push_back(pObserver);
    }

    virtual void Detach(CObserver* pObserver)
    {
        m_listObserver.remove(pObserver);
    }

    virtual void Notify()
    {
        for (CObserver* pObserver : m_listObserver)
            pObserver->UpDate();
    }
};

// 具体通知者类
class CConcreteSubject : public CSubject
{
private:
    string m_szSubjectState;

public:
    void SetSubjectState(string szSubjectState)
    {
        m_szSubjectState = szSubjectState;
    }

    string GetSubjectState()
    {
        return m_szSubjectState;
    }
};

// 具体观察者类
class CConcreteObserver : public CObserver
{
private:
    string m_szName;
    CConcreteSubject* m_pSubject;

public:
    CConcreteObserver(CConcreteSubject* pSubject, string szName)
    {
        m_szName = szName;
        m_pSubject = pSubject;
    }

    virtual void UpDate()
    {
        cout << "观察者[" << m_szName << "]的新状态是[" 
            << m_pSubject->GetSubjectState() << "]" << endl;
    }

    void SetSubject(CConcreteSubject* pSubject)
    {
        m_pSubject = pSubject;
    }

    CSubject* GetSubject()
    {
        return m_pSubject;
    }
};

int main()
{
    CConcreteSubject ConcreteSubject;
    CConcreteObserver ConcreteObserver1(&ConcreteSubject, "X");
    CConcreteObserver ConcreteObserver2(&ConcreteSubject, "Y");
    CConcreteObserver ConcreteObserver3(&ConcreteSubject, "Z");

    ConcreteSubject.Attach(&ConcreteObserver1);
    ConcreteSubject.Attach(&ConcreteObserver2);
    ConcreteSubject.Attach(&ConcreteObserver3);

    ConcreteSubject.Detach(&ConcreteObserver2);

    ConcreteSubject.SetSubjectState("ABC");

    ConcreteSubject.Notify();

    system("pause");
    return 0;
}

 

输出结果：

 

 

 

 

 注：C++是没有C#中的委托事件这种语法的，但是可以用函数指针来实现，笔者比较懒，没写。

例：前台监测老板是否回来了。

代码如下：

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

//class CSecretary;
class CSubject;
// 抽象观察者类
class CObserver
{
protected:
    string m_szName;
    //CSecretary* m_pSecretary;
    CSubject* m_pSubject;

public:
    //CObserver(string szName, CSecretary* pSecretary);
    CObserver(string szName, CSubject* pSubject) : m_szName(szName), m_pSubject(pSubject) {};
    virtual ~CObserver() {};
    virtual void UpDate() {};
};

//// 秘书类(双向耦合代码)
//class CSecretary
//{
//private:
//    list<CObserver*> m_listCObserver;
//    string m_szAction;
//
//public:
//    CSecretary() {}
//
//    virtual ~CSecretary()
//    {
//        if (!m_listCObserver.empty())
//        {
//            m_listCObserver.clear();
//        }
//    }
//
//    virtual void Attach(CObserver* pObserver)
//    {
//        m_listCObserver.push_back(pObserver);
//    }
//
//    virtual void Detach(CObserver* pDelObserver)
//    {
//        if (!m_listCObserver.empty())
//        {
//            m_listCObserver.remove(pDelObserver);
//        }
//    }
//
//    virtual void Notify()
//    {
//        for (CObserver* pObserver : m_listCObserver)
//        {
//            pObserver->UpDate();
//        }
//    }
//
//    void SetSecretaryAction(string szAction)
//    {
//        m_szAction = szAction;
//    }
//
//    string GetSecretaryAction()
//    {
//        return m_szAction;
//    }
//};

// 抽象主题类
class CSubject
{
private:
    list<CObserver*> m_listCObserver;
    string m_szAction;

public:
    CSubject() {};
    virtual ~CSubject()
    {
        if (!m_listCObserver.empty())
        {
            m_listCObserver.clear();
        }
    }

    virtual void Attach(CObserver* pObserver)
    {
        m_listCObserver.push_back(pObserver);
    }

    virtual void Detach(CObserver* pDelObserver)
    {
        if (!m_listCObserver.empty())
        {
            m_listCObserver.remove(pDelObserver);
        }
    }

    virtual void Notify()
    {
        for (CObserver* pObserver : m_listCObserver)
        {
            pObserver->UpDate();
        }
    }

    void SetSubjectState(string szAction)
    {
        m_szAction = szAction;
    }

    string GetSubjectState()
    {
        return m_szAction;
    }
};

// 看股票的同事(具体观察者类)
class CStockObserver : public CObserver
{
public:
    //CStockObserver(string szName, CSecretary* pSecretary)
    //    : CObserver(szName, pSecretary)
    //{
    //
    //}

    CStockObserver(string szName, CSubject* pSubject)
        : CObserver(szName, pSubject) {}

    virtual ~CStockObserver() {}

    virtual void UpDate()
    {
        //cout << "[" << m_pSecretary->GetSecretaryAction() << "]"
        //    << "[" << m_szName << "]" << "关闭股票行情，继续工作" << endl;

        cout << "[" << m_pSubject->GetSubjectState() << "]"
            << "[" << m_szName << "]" << "关闭股票行情，继续工作。。。" << endl;
    }
};

// 看NBA的同事(具体观察者类)
class CNBAObserver : public CObserver
{
public:
    //CNBAObserver(string szName, CSecretary* pSecretary)
    //    : CObserver(szName, pSecretary) {}

    CNBAObserver(string szName, CSubject* pSubject)
        : CObserver(szName, pSubject) {}

    virtual ~CNBAObserver() {}

    virtual void UpDate()
    {
        //cout << "[" << m_pSecretary->GetSecretaryAction() << "]"
        //    << "[" << m_szName << "]" << "关闭NBA直播，继续工作" << endl;

        cout << "[" << m_pSubject->GetSubjectState() << "]"
            << "[" << m_szName << "]" << "关闭NBA直播，继续工作。。。" << endl;
    }
};

// 我嫌麻烦，把具体主题类的共有内容放到抽象主题类里写了，懒得写两遍
// 老板(具体主题类)
class CBoss : public CSubject
{
};

// 秘书(具体主题类)
class CReception : public CSubject
{
};

// C++资源回收，记住哪里创建就要哪里释放
// 其他作用域只是指针传递，如果在别的地方释放，容易导致多次释放报错
int main()
{
    //CSecretary Secretary;
    CBoss Boss;

    //CStockObserver StockObserver("GHL", &Secretary);
    //CNBAObserver NBAObserver("GGG", &Secretary);
    CStockObserver StockObserver("GHL", &Boss);
    CNBAObserver NBAObserver("GGG", &Boss);

    //Secretary.Attach(&StockObserver);
    //Secretary.Attach(&NBAObserver);

    Boss.Attach(&StockObserver);
    Boss.Attach(&NBAObserver);

    //Secretary.SetSecretaryAction("老板回来了!");
    Boss.SetSubjectState("我胡汉三回来了!");

    //Secretary.Notify();
    Boss.Notify();


    cout << "\n华丽的分割线\n" << endl;
    CReception Reception;

    CStockObserver StockObserve1("123", &Reception);
    CNBAObserver NBAObserve1("456", &Reception);

    Reception.Attach(&StockObserve1);
    Reception.Attach(&NBAObserve1);
    Reception.Detach(&NBAObserve1);

    Reception.SetSubjectState("老板回来了!");

    Reception.Notify();

    system("pause");
    return 0;
}

输出结果：