用C++实现观察者模式的几种变体

麻花痒  论坛元老 | 2024-10-1 19:42:23 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 1043|帖子 1043|积分 3129

观察者模式的标准定义

定义一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当这个主题对象的状态发生改变时，会关照所有观察者对象，使它们可以或许主动更新自己的状态。
观察者模式的标准结构图


观察者模式的标准实现

Subject（抽象主题）

Subject.h
  1. #pragma once
  3. #include <list>
  4. #include <string>
  6. class Observer;
  8. class Subject
  9. {
  10. public:
  11.         virtual ~Subject();
  13.         virtual void addObserver(Observer* obsv);
  15.         virtual void removeOvserver(Observer* obsv);
  17.         virtual void notify();
  19. private:
  20.         std::list<Observer *> mObserverList;
  22. };
复制代码
Subject.cpp
  1. #include "Subject.h"
  3. #include "Observer.h"
  5. Subject::~Subject()
  6. {
  7.         if (!mObserverList.empty())
  8.         {
  9.                 mObserverList.clear();
  10.         }
  11. }
  13. void Subject::addObserver(Observer* obsv)
  14. {
  15.         if (nullptr == obsv)
  16.                 return;
  17.         bool bExist = false;
  18.         std::list<Observer*>::const_iterator iter = mObserverList.begin();
  19.         for (; iter != mObserverList.end(); ++iter)
  20.         {
  21.                 Observer* const curObsv = iter.operator*();
  22.                 //*iter == obsv;
  23.                 if (curObsv == obsv)
  24.                 {
  25.                         bExist = true;
  26.                         break;
  27.                 }
  28.         }
  30.         if (bExist)
  31.                 return;
  32.         mObserverList.push_back(obsv);
  33. }
  35. void Subject::removeOvserver(Observer* obsv)
  36. {
  37.         if (mObserverList.empty() || (nullptr == obsv))
  38.                 return;
  39.         bool bExist = false;
  40.         std::list<Observer*>::const_iterator iter = mObserverList.begin();
  41.         for (; iter != mObserverList.end(); ++iter)
  42.         {
  43.                 Observer* const curObsv = *iter;
  44.                 if (curObsv == obsv)
  45.                 {
  46.                         bExist = true;
  47.                         break;
  48.                 }
  49.         }
  51.         if (bExist)
  52.                 mObserverList.remove(obsv);
  53. }
  55. void Subject::notify()
  56. {
  57.         std::list<Observer*>::const_iterator iter;
  58.         for (iter = mObserverList.begin(); iter != mObserverList.end(); ++iter)
  59.         {
  60.                 Observer* const curObsv = *iter;
  61.                 curObsv->update();
  62.         }
  63. }
复制代码
这里先说两个概念：原语函数、钩子函数
原语函数，即纯虚函数，意思就是必须在子类中重定义的函数；
钩子函数，即虚函数，意思是可以在子类中重定义的函数。
ConcreteSubject（具体主题）

ConcreteSubject.h
  1. #pragma once
  2. #include "Subject.h"
  3. class ConcreteSubjectA :
  4.     public Subject
  5. {
  6. public:
  7.     void setState(bool b);
  8.     bool getState() const;
  10.     void changedState();
  12. private:
  13.     bool mSendToA = false;
  14.     bool mSendToB = false;
  15. };
复制代码
ConcreteSubject.cpp
  1. #include "ConcreteSubjectA.h"
  2. #include <iostream>
  4. void ConcreteSubjectA::setState(bool b)
  5. {
  6.         mSendToA = mSendToB = b;
  7.         changedState();
  8. }
  10. bool ConcreteSubjectA::getState() const
  11. {
  12.         return (mSendToA && mSendToB);
  13. }
  15. void ConcreteSubjectA::changedState()
  16. {
  17.         std::cout << "刘亦菲来啦~" << std::endl;
  19.         if (getState())
  20.         {
  21.                 notify();
  22.         }
  23. }
复制代码
Observer（抽象观察者）

Observer.h
  1. #pragma once
  3. class string;
  5. class Observer
  6. {
  7. public:
  8.         Observer();
  9.         virtual ~Observer();
  11.         virtual void update() = 0;
  13. };
复制代码
Observer.cpp
  1. #include "Observer.h"
  3. Observer::Observer()
  4. {
  5. }
  7. Observer::~Observer()
  8. {
  9. }
复制代码
ConcreteObserverA（具体观察者A）

ConcreteObserverA.h
  1. #pragma once
  2. #include "Observer.h"
  3. class ConcreteObserverA :
  4.     public Observer
  5. {
  6. public:
  7.     ConcreteObserverA();
  8.     ~ConcreteObserverA();
  10.     virtual void update() override;
  12. };
复制代码
ConcreteObserver.cpp
  1. #include "ConcreteObserverA.h"
  2. #include <iostream>
  4. ConcreteObserverA::ConcreteObserverA()
  5. {
  6. }
  8. ConcreteObserverA::~ConcreteObserverA()
  9. {
  10. }
  12. void ConcreteObserverA::update()
  13. {
  14.         std::cout << "我要上报给领导！" << std::endl;
  15. }
复制代码
ConcreteObserverB（具体观察者B）

ConcreteObserverB.h
  1. #pragma once
  2. #include "Observer.h"
  4. class ConcreteSubjectA;
  6. class ConcreteObserverB :
  7.     public Observer
  8. {
  9. public:
  10.     ConcreteObserverB();
  11.     virtual ~ConcreteObserverB();
  13.     virtual void update() override;
  15. };
复制代码
ConcreteObserverB.cpp
  1. #include "ConcreteObserverB.h"
  3. #include "ConcreteSubjectA.h"
  5. #include <iostream>
  7. ConcreteObserverB::ConcreteObserverB()
  8. {
  9. }
  11. ConcreteObserverB::~ConcreteObserverB()
  12. {
  14. }
  16. void ConcreteObserverB::update()
  17. {
  18.         std::cout << "我要通知其他人！" << std::endl;
  19. }
复制代码
主程序简单调用

  1. #include "ConcreteObserverA.h"
  2. #include "ConcreteSubjectA.h"
  3. #include "ConcreteObserverB.h"
  5. #include <iostream>
  7. int main()
  8. {
  9.     // Standard version
  10.     ConcreteObserverA* obsvA = new ConcreteObserverA();
  11.     ConcreteObserverB* obsvB = new ConcreteObserverB();
  12.     ConcreteSubjectA* subA = new ConcreteSubjectA();
  13.     subA->addObserver(obsvA);
  14.     subA->addObserver(obsvB);
  15.     subA->setState(true);
  16.     subA->removeOvserver(obsvB);
  17.     subA->removeOvserver(obsvA);
  19.     return EXIT_SUCCESS;
  20. }
复制代码
实在到这里，可以结束了；但是，好像又远远不敷。哪里不敷呢？
你难道不以为这两个观察者A、B有点太轻信于主题A了吗？不管谁给它们发消息，它们都相信 ，如许容易上当上当呀——说是刘亦菲来了，实在是刘姥姥来啦~。
观察者A、B也很委屈，腹诽道：我也不知道是谁给我的消息，我只知道，有消息，我就得做出反应；哪里还管得了你的、他的。
这还不简单…
观察者变身一

Observer.h
  1. #pragma once
  3. #include "Subject.h"
  5. class Observer_SecondVer // 响应固定主题
  6. {
  7. public:
  8.         Observer_SecondVer();
  9.         Observer_SecondVer(Subject* subject);
  10.         virtual ~Observer_SecondVer();
  12.         virtual void update(Subject* subject = nullptr) = 0;
  14. protected:
  15.         Subject* mSubject = nullptr;
  17. };
复制代码
ConcreteObserverA.h
  1. #pragma once
  2. #include "Observer.h"
  4. class ConcreteObserverA_SecondVer : public Observer_SecondVer
  5. {
  6. public:
  7.     ConcreteObserverA_SecondVer();
  8.     ConcreteObserverA_SecondVer(Subject* subject);
  9.     ~ConcreteObserverA_SecondVer();
  11.     virtual void update(Subject* subject = nullptr) override;
  13.     void doSomething();
  14. };
复制代码
ConcreteObserverA.cpp
  1. #include "ConcreteObserverA.h"
  2. #include <iostream>
  4. ConcreteObserverA_SecondVer::ConcreteObserverA_SecondVer()
  5. {
  6. }
  8. ConcreteObserverA_SecondVer::ConcreteObserverA_SecondVer(Subject* subject) : Observer_SecondVer(subject)
  9. {
  10. }
  12. ConcreteObserverA_SecondVer::~ConcreteObserverA_SecondVer()
  13. {
  14. }
  16. void ConcreteObserverA_SecondVer::update(Subject* subject)
  17. {
  18.         if (subject && subject == mSubject)
  19.         {
  20.                 doSomething();
  21.         }
  22. }
  24. void ConcreteObserverA_SecondVer::doSomething()
  25. {
  26.         std::cout << "通知老板！" << std::endl;
  27. }
复制代码
ConcreteObserverB.h
  1. #pragma once
  2. #include "Observer.h"
  4. class ConcreteSubjectA;
  6. class ConcreteObserverB_SecondVer : public Observer_SecondVer
  7. {
  8. public:
  9.     ConcreteObserverB_SecondVer();
  10.     ConcreteObserverB_SecondVer(ConcreteSubjectA* subject);
  11.     ~ConcreteObserverB_SecondVer();
  13.     virtual void update(Subject* subject = nullptr) override;
  15.     void doSomething();
  16. };
复制代码
ConcreteObserverB.cpp
  1. #include "ConcreteObserverB.h"
  3. #include "ConcreteSubjectA.h"
  5. #include <iostream>
  7. ConcreteObserverB_SecondVer::ConcreteObserverB_SecondVer()
  8. {
  9. }
  11. ConcreteObserverB_SecondVer::ConcreteObserverB_SecondVer(ConcreteSubjectA* subject) : Observer_SecondVer(subject)
  12. {
  13. }
  15. ConcreteObserverB_SecondVer::~ConcreteObserverB_SecondVer()
  16. {
  17. }
  19. void ConcreteObserverB_SecondVer::update(Subject* subject)
  20. {
  21.         if (subject && subject == mSubject)
  22.         {
  23.                 doSomething();
  24.         }
  25. }
  27. void ConcreteObserverB_SecondVer::doSomething()
  28. {
  29.         std::cout << "通知其他人！" << std::endl;
  30. }
复制代码
怎么样？以后，只要观察者A、B认定了主题A的消息，都进行相应，是不是就没那么容易上当上当了。
突然，观察者A又有点其他的想法，弱弱地问道：“那个~我不想只看刘亦菲，只要是美女，能不能都给我发消息呀？”
啊~ 你这~
于是乎…
主题变身一/二 + 观察者变身二

Subject.h
  1. #pragma once
  3. #include <list>
  4. #include <string>
  6. class Observer;
  7. class Observer_SecondVer;
  8. class Observer_ThirdVer;
  10. class Subject
  11. {
  12. public:
  13.         virtual ~Subject();
  15.         virtual void addObserver(Observer* obsv);
  17.         virtual void removeOvserver(Observer* obsv);
  19.         virtual void notify();
  21.         virtual void addObserver(Observer_SecondVer* obsv);
  23.         virtual void removeOvserver(Observer_SecondVer* obsv);
  25.         virtual void notify_SecondVer();
  27.         virtual void addObserver(Observer_ThirdVer* obsv);
  29.         virtual void removeOvserver(Observer_ThirdVer* obsv);
  31.         virtual void notify_ThirdVer();
  33. private:
  34.         std::list<Observer *> mObserverList;
  35.         std::list<Observer_SecondVer*> mObserverList_SecondVer;
  36.         std::list<Observer_ThirdVer*> mObserverList_ThirdVer;
  38. };
复制代码
Subject.cpp
  1. void Subject::notify_SecondVer()
  2. {
  3.         std::list<Observer_SecondVer*>::const_iterator iter;
  4.         for (iter = mObserverList_SecondVer.begin(); iter != mObserverList_SecondVer.end(); ++iter)
  5.         {
  6.                 Observer_SecondVer* const curObsv = *iter;
  7.                 curObsv->update(this);
  8.         }
  9. }
  11. void Subject::notify_ThirdVer()
  12. {
  13.         std::list<Observer_ThirdVer*>::const_iterator iter;
  14.         for (iter = mObserverList_ThirdVer.begin(); iter != mObserverList_ThirdVer.end(); ++iter)
  15.         {
  16.                 Observer_ThirdVer* const curObsv = *iter;
  17.                 curObsv->update(this, std::string("有美女！"));
  18.         }
  19. }
复制代码
ConcreteSubjectA.h
  1. #pragma once
  2. #include "Subject.h"
  3. class ConcreteSubjectA :
  4.     public Subject
  5. {
  6. public:
  7.     void setState(bool b);
  8.     bool getState() const;
  10.     void setStateA(bool b);
  11.     bool getStateA() const;
  13.     void setStateB(bool b);
  14.     bool getStateB() const;
  16.     void changedState();
  18. private:
  19.     bool mSendToA = false;
  20.     bool mSendToB = false;
  21. };
复制代码
ConcreteSubjectA.cpp
  1. #include "ConcreteSubjectA.h"
  2. #include <iostream>
  4. void ConcreteSubjectA::setState(bool b)
  5. {
  6.         mSendToA = mSendToB = b;
  7.         changedState();
  8. }
  10. bool ConcreteSubjectA::getState() const
  11. {
  12.         return (mSendToA && mSendToB);
  13. }
  15. void ConcreteSubjectA::setStateA(bool b)
  16. {
  17.         std::cout << "美女来啦~" << std::endl;
  18.         mSendToA = b;
  19.         changedState();
  20. }
  22. bool ConcreteSubjectA::getStateA() const
  23. {
  24.         return mSendToA;
  25. }
  27. void ConcreteSubjectA::setStateB(bool b)
  28. {
  29.         std::cout << "刘亦菲来啦~" << std::endl;
  30.         mSendToB = b;
  31.         changedState();
  32. }
  34. bool ConcreteSubjectA::getStateB() const
  35. {
  36.         return mSendToB;
  37. }
  39. void ConcreteSubjectA::changedState()
  40. {
  41.         if (getStateA())
  42.         {
  43.                 notify_SecondVer();
  44.         }
  45.         else if (getStateB())
  46.         {
  47.                 notify_ThirdVer();
  48.         }
  49.         else if (getState())
  50.         {
  51.                 notify();
  52.                 notify_SecondVer();
  53.                 notify_ThirdVer();
  54.         }
  55.         else
  56.         {
  57.                 notify();
  58.         }
  59. }
复制代码
Observer.h
  1. #pragma once
  3. #include "Subject.h"
  5. class string;
  7. class Observer_ThirdVer // 响应固定主题 + 固定消息
  8. {
  9. public:
  10.         virtual ~Observer_ThirdVer() {}
  12.         virtual void update(Subject* subject, const std::string& info) = 0;
  14. };
复制代码
ConcreteObserverA.h
  1. #pragma once
  2. #include "Observer.h"
  4. class ConcreteObserverA_ThirdVer : public Observer_ThirdVer
  5. {
  6. public:
  7.     ConcreteObserverA_ThirdVer() {}
  8.     ConcreteObserverA_ThirdVer(Subject* subject);
  9.     virtual ~ConcreteObserverA_ThirdVer();
  11.     virtual void update(Subject* subject, const std::string& info) override;
  13. protected:
  14.     Subject* mSubject = nullptr;
  16. };
复制代码
ConcreteObserverA.cpp
  1. #include "ConcreteObserverA.h"
  2. #include <iostream>
  4. ConcreteObserverA_ThirdVer::ConcreteObserverA_ThirdVer(Subject* subject) : mSubject(subject)
  5. {
  6. }
  8. ConcreteObserverA_ThirdVer::~ConcreteObserverA_ThirdVer()
  9. {
  10.         if (mSubject)
  11.                 mSubject = nullptr;
  12. }
  14. void ConcreteObserverA_ThirdVer::update(Subject* subject, const std::string& info)
  15. {
  16.         if (subject && subject == mSubject)
  17.         {
  18.                 if (info == "有美女！")
  19.                 {
  20.                         std::cout << "哇~" << std::endl;
  21.                 }
  22.                 else
  23.                 {
  24.                         std::cout << "(ˉ▽￣～) 切~~" << std::endl;
  25.                 }
  26.         }
  27. }
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

麻花痒

论坛元老
这个人很懒什么都没写!

楼主热帖

标签云

AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表