1. 一个遍历问题导致的低效率范例

1.1 场景：

在线游戏中，多人聊天。同家族的所有成员可收到家族成员的聊天内容，非本家族不能收到。

1.2 示例代码

  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #include <list>
  6. using namespace std;
  8. class Fighter;
  9. list<Fighter*> g_playerList;
  11. // 玩家父类(以往的战斗者类)
  12. class Fighter {
  13. public:
  14.     Fighter(int playerID, string playerName)
  15.         : m_playerID(playerID)
  16.         , m_playerName(playerName)
  17.     {
  18.         // -1 表示没有加入任何家族
  19.         m_familyID = -1;
  20.     }
  22.     virtual ~Fighter() { }
  24.     // 加入家族的时候要设置家族ID
  25.     void setFamilyID(int familyID) {
  26.         m_familyID = familyID;
  27.     }
  29.     // 玩家说了某句话
  30.     void sayWords(string content) {
  31.         // 该玩家属于某个家族，应该把聊天内容信息传送到给该家族的其他玩家
  32.         for (auto iter = g_playerList.begin(); iter != g_playerList.end(); iter++) {
  33.             if (m_familyID == (*iter)->m_familyID){
  34.                 // 同一个家族的其他玩家也应该收到聊天信息
  35.                 notifyWords(*iter, content);
  36.             }
  37.         }
  38.     }
  40. private:
  41.     void notifyWords(Fighter* otherPlayer, string content) {
  42.         // 显示信息
  43.         cout << otherPlayer->m_playerName << " receives the message sent by " << m_playerName << ", the chat message sent was" << content << endl;
  44.     }
  45. private:
  46.     // 玩家ID,全局唯一
  47.     int m_playerID;
  48.     // 玩家名字
  49.     string m_playerName;
  50.     // 家族ID
  51.     int m_familyID;
  52. };
  54. // 战士类玩家，父类为Fighter
  55. class Warrior :public Fighter {
  56. public:
  57.     Warrior(int playerID, string playerName)
  58.         : Fighter(playerID, playerName)
  59.     {
  60.     }
  61. };
  63. // 法师类玩家，父类为Fighter
  64. class Mage :public Fighter {
  65. public:
  66.     Mage(int playerID, string playerName)
  67.         : Fighter(playerID, playerName)
  68.     {
  69.     }
  70. };
  72. void observer1() {
  73.     // 创建游戏玩家(实际数据应来自数据库)
  74.     Fighter* warrior1 = new Warrior(10, "fighter1");
  75.     warrior1->setFamilyID(100);
  76.     g_playerList.push_back(warrior1);
  78.     Fighter* warrior2 = new Warrior(20, "fighter2");
  79.     warrior2->setFamilyID(100);
  80.     g_playerList.push_back(warrior2);
  82.     Fighter* mage1 = new Mage(30, "mage1");
  83.     mage1->setFamilyID(100);
  84.     g_playerList.push_back(mage1);
  86.     Fighter* mage2 = new Mage(40, "mage2");
  87.     mage2->setFamilyID(200);
  88.     g_playerList.push_back(mage2);
  90.     // 当某个玩家聊天时,同族人都应该收到该信息
  91.     warrior1->sayWords("The whole tribe immediately assembled in the marshes.");
  93.     delete warrior1;
  94.     delete warrior2;
  95.     delete mage1;
  96.     delete mage2;
  98. }

上述代码实现了该功能需求，但效率不高。sayWords这个函数中的for循环，如果玩家数量比较少的时候不受影响，但玩家数量增多至数万时就需要考虑效率问题，此时引入观察者模式。

2. 引入观察者模式

2.1 定义（实现意图）

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

2.2 示例代码

  1. #pragma once
  2. #include <iostream>
  3. #include <list>
  4. #include <map>
  5. #include <string>
  6. using namespace std;
  8. class Fighter; // 类前向声明
  10. // 通知器父类
  11. class Notifier {
  12. public:
  13.     // 把要被通知的玩家加入到列表中
  14.     virtual void addToList(Fighter* player) = 0;
  15.     // 把不想被通知的玩家从列表中去除
  16.     virtual void removeFromList(Fighter* player) = 0;
  17.     // 通知的一些细节信息
  18.     virtual void notify(Fighter* talker, string comtent) = 0;
  19.     virtual ~Notifier() { }
  20. };
  22. // 玩家父类(以往的战斗者类)
  23. class Fighter {
  24. public:
  25.     Fighter(int playerID, string playerName)
  26.         : m_playerID(playerID)
  27.         , m_playerName(playerName)
  28.     {
  29.         // -1 表示没有加入任何家族
  30.         m_familyID = -1;
  31.     }
  33.     virtual ~Fighter() { }
  35.     // 加入家族的时候要设置家族ID
  36.     void setFamilyID(int familyID)
  37.     {
  38.         m_familyID = familyID;
  39.     }
  41.     // 获取家族ID
  42.     int getFamilyID()
  43.     {
  44.         return m_familyID;
  45.     }
  47.     // 玩家说了某句话
  48.     void sayWords(Notifier* notifier, string content)
  49.     {
  50.         notifier->notify(this, content);
  51.     }
  53.     // 通知该玩家接收到其他玩家发送来的聊天信息,虚函数子类可以覆盖以实现不同的功能
  54.     void notifyWords(Fighter* talker, string content)
  55.     {
  56.         // 显示信息
  57.         cout << m_playerName << " receives the message sent by " << talker->m_playerName
  58.              << ", the chat message sent was" << content << endl;
  59.     }
  61. private:
  62.     // 玩家ID,全局唯一
  63.     int m_playerID;
  64.     // 玩家名字
  65.     string m_playerName;
  66.     // 家族ID
  67.     int m_familyID;
  68. };
  70. // 战士类玩家，父类为Fighter
  71. class Warrior : public Fighter {
  72. public:
  73.     Warrior(int playerID, string playerName)
  74.         : Fighter(playerID, playerName)
  75.     {
  76.     }
  77. };
  79. // 法师类玩家，父类为Fighter
  80. class Mage : public Fighter {
  81. public:
  82.     Mage(int playerID, string playerName)
  83.         : Fighter(playerID, playerName)
  84.     {
  85.     }
  86. };
  88. // 聊天信息通知器
  89. class TalkNotifier : public Notifier {
  90. public:
  91.     // 将玩家增加到家族列表中来
  92.     void addToList(Fighter* player) override
  93.     {
  94.         int tempFamilyid = player->getFamilyID();
  96.         if (tempFamilyid == -1) {
  97.             return;
  98.         }
  100.         // 加入了某个家族
  101.         auto iter = m_familyList.find(tempFamilyid);
  102.         if (iter != m_familyList.end()) { // 家族ID存在
  103.             iter->second.push_back(player);
  104.         } else { // 家族ID不存在
  105.             list<Fighter*> coll;
  106.             m_familyList.insert(make_pair(tempFamilyid, coll));
  107.             m_familyList[tempFamilyid].push_back(player);
  108.         }
  109.     }
  111.     // 将玩家从家族列表中删除
  112.     void removeFromList(Fighter* player) override
  113.     {
  114.         int tempFamilyid = player->getFamilyID();
  115.         if (tempFamilyid == -1) {
  116.             return;
  117.         }
  119.         auto iter = m_familyList.find(tempFamilyid);
  120.         if (iter == m_familyList.end()) {
  121.             return;
  122.         }
  123.         iter->second.remove(player);
  124.     }
  125.     // 家族中某玩家说了句话，调用该函数来通知家族中所有人
  126.     void notify(Fighter* talker, string content) override
  127.     {
  128.         int tempFamilyid = talker->getFamilyID();
  129.         if (tempFamilyid == -1) {
  130.             return;
  131.         }
  133.         auto iter = m_familyList.find(tempFamilyid);
  134.         if (iter == m_familyList.end()) {
  135.             return;
  136.         }
  137.         list<Fighter*> coll = iter->second;
  138.         // 遍历该家族的所有成员
  139.         for (auto iterList = coll.begin(); iterList != coll.end(); ++iterList) {
  140.             (*iterList)->notifyWords(talker, content);
  141.         }
  142.     }
  144. private:
  145.     // key为家族ID, value代表该家族中所有玩家列表
  146.     map<int, list<Fighter*>> m_familyList;
  147. };
  149. void observer1()
  150. {
  151.     Fighter* warrior1 = new Warrior(10, "warrior1");
  152.     warrior1->setFamilyID(100);
  154.     Fighter* warrior2 = new Warrior(20, "warrior2");
  155.     warrior2->setFamilyID(100);
  157.     Fighter* mage1 = new Mage(30, "mage1");
  158.     mage1->setFamilyID(100);
  160.     Fighter* mage2 = new Mage(40, "mage2");
  161.     mage2->setFamilyID(200);
  163.     // 创建通知器
  164.     Notifier* notifier = new TalkNotifier();
  165.     // 玩家增加到家族列表中来，这样才能收到家族聊天记录
  166.     notifier->addToList(warrior1);
  167.     notifier->addToList(warrior2);
  168.     notifier->addToList(mage1);
  169.     notifier->addToList(mage2);
  171.     // 当某游戏玩家聊天时，同族玩家都应该收到该信息
  172.     string chatMsg1 = "The whole tribe immediately assembled in the marshes.";
  173.     warrior1->sayWords(notifier, chatMsg1);
  175.     cout << "Warrior2 doesn't want to receive any more chat messages from the rest of the family..." << endl;
  176.     notifier->removeFromList(warrior2);
  177.     string chatMsg2 = "Please follow the group leader's instructions.";
  178.     mage1->sayWords(notifier, chatMsg2);
  180.     delete warrior1;
  181.     delete warrior2;
  182.     delete mage1;
  183.     delete mage2;
  184.     delete notifier;
  185. }

2.3 类图

13.观察者模式.svg
观察者模式的四种角色

  • Subject（主题）：观察目标，这里指Notifier类。
  • ConcreteSubject（具体主题）：这里指TalkNotifier类。
  • Observer（观察者）：这里指Fighter类。
  • ConcreteObserver(具体观察者）：这里指Warrior和Mage子类。

2.4 观察者模式的特点

  • 在观察者和观察目标之间建立了一个抽象的耦合
  • 观察目标会向观察者列表中的所有观察者发送通知

  • 可以通过增加代码来增加新的观察者或者观察目标，符合开闭原则

    2.5 应用联想

  • 救援家族成员镖车

  • 将新闻推荐给符合其胃口的读者
  • 通过改变自身绘制的图形来真实的反应公司的销售数据。
  • 炮楼只会对30米内的玩家（列表内玩家）进行攻击。