Observer(观察者模式)

1. 意图

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。

在观察者模式中,有两类对象:被观察者(Subject)和观察者(Observer)。被观察者是一个具有状态的对象,当其状态发生变化时,会通知所有的观察者。观察者是一个依赖于被观察者的对象,它会接收到被观察者的通知,并进行相应的处理。

2. 适用性

《GOF设计模式:可复用面向对象软件的基础》中描述如下:

  • 当一个抽象模型有两方面,其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们各自独立地自主改变和复用。
  • 当对一个对象的改变需要同时改变其它对象,而不知道具体有多少对象有待改变。
  • 当一个对象必须通知其它对象,而它又不能假定对象是谁。即对象之间关系是解耦合的。

3. 实现

cpp 复制代码
#include <iostream>
#include <string>
#include <vector>

class Observer {
public:
  virtual ~Observer() {}

  virtual void Update(const std::string &msg) = 0;
};

class NetObserver : public Observer {
public:
  virtual void Update(const std::string &msg) override {
    std::cout << "NetObserver recv msg: " << msg << std::endl;
  }
};

class SerialObserver : public Observer {
public:
  virtual void Update(const std::string &msg) override {
    std::cout << "SerialObserver recv msg: " << msg << std::endl;
  }
};

class Subject {
public:
  virtual ~Subject() {}

  bool Attach(Observer *ptr) {
    if (ptr == nullptr)
      return false;
    m_vecObserver.push_back(ptr);
    return true;
  }
  void Detach(const Observer *ptr) {
    for (auto iter = m_vecObserver.begin(); iter != m_vecObserver.end();
         ++iter) {
      if (*iter != ptr)
        continue;
      m_vecObserver.erase(iter);
    }
  }
  void Notify(const std::string &msg) {
    for (Observer *ptr : m_vecObserver)
      ptr->Update(msg);
  }

private:
  std::vector<Observer *> m_vecObserver;
};

class NetSubject : public Subject {
public:
  void DoSomething() { Notify("NetSubject msg"); }
};

class SerialSubject : public Subject {
public:
  void DoSomething() { Notify("SerialSubject msg"); }
};

void Test() {
  NetObserver *net1 = new NetObserver;
  NetObserver *net2 = new NetObserver;
  SerialObserver *serial1 = new SerialObserver;
  SerialObserver *serial2 = new SerialObserver;

  NetSubject *netSub = new NetSubject;
  SerialSubject *serialSub = new SerialSubject;

  netSub->Attach(net1);
  netSub->DoSomething();
  std::cout << "------------------------------" << std::endl;
  netSub->Attach(net2);
  netSub->DoSomething();
  std::cout << "------------------------------" << std::endl;

  serialSub->Attach(serial1);
  serialSub->DoSomething();
  std::cout << "------------------------------" << std::endl;
  serialSub->Attach(serial2);
  serialSub->DoSomething();

  delete net1;
  delete net2;
  delete serial1;
  delete serial2;
  delete netSub;
  delete serialSub;
}

int main() {
  Test();
  return 0;
}

执行结果

|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| NetObserver recv msg: NetSubject msg ------------------------------ NetObserver recv msg: NetSubject msg NetObserver recv msg: NetSubject msg ------------------------------ SerialObserver recv msg: SerialSubject msg ------------------------------ SerialObserver recv msg: SerialSubject msg SerialObserver recv msg: SerialSubject msg |

4. 优缺点

  • 松耦合性:被观察者和观察者之间是松耦合的,它们之间仅通过接口或抽象类进行通信,不需要直接相互引用,可以独立变化。

  • 可扩展性:可以随时增加新的观察者,而不需要修改被观察者的代码,也可以很容易地添加新的被观察者。

  • 可重用性:观察者模式可以在不同的场景中重复使用,不需要重写逻辑。

  • 实时更新:被观察者一旦发生变化,所有的观察者都会实时收到通知并进行相应的更新,保证了数据的实时性。

  • 观察者过多:如果观察者的数量过多,通知所有观察者可能会导致性能问题,影响系统的运行效率。

  • 顺序控制困难:观察者之间是一种松散的耦合关系,无法控制观察者接收通知的顺序,可能会导致一些不可预测的问题。

  • 循环依赖问题:如果观察者与被观察者之间存在循环依赖,可能会导致系统出现问题。

5. 模板实现

cpp 复制代码
#include <functional>
#include <iostream>
#include <string>
#include <unordered_map>

class ObserverA {
public:
  void UpdateA(const std::string &msg) {
    std::cout << "ObserverA msg: " << msg << std::endl;
  }
};

class ObserverB {
public:
  void UpdateB(const std::string &msg) {
    std::cout << "ObserverB msg: " << msg << std::endl;
  }
};

template <typename Func> class Event {
public:
  Event() : m_observeId(0) {}
  virtual ~Event() {}

  int Attach(Func &&f) { return Assign(f); }
  int Attach(const Func &f) { return Assign(f); }
  void Detach(int key) { m_mapOberserve.erase(key); }
  template <typename... Args> void Notify(Args &&...args) {
    for (auto &it : m_mapOberserve) {
      it.second(std::forward<Args>(args)...);
    }
  }

private:
  Event(const Event &) = delete;
  Event &operator=(const Event &) = delete;

  template <typename F> int Assign(F &&f) {
    m_mapOberserve.emplace(m_observeId++, std::forward<F>(f));
    return m_observeId - 1;
  }

private:
  int m_observeId;
  std::unordered_map<int, Func> m_mapOberserve;
};
void Test() {
  Event<std::function<void(const std::string &)>> event;
  ObserverA oba;
  int key =
      event.Attach(std::bind(&ObserverA::UpdateA, oba, std::placeholders::_1));
  event.Notify("AAAAA");
  std::cout << "-----------------------" << std::endl;
  ObserverB obb;

  event.Attach(std::bind(&ObserverB::UpdateB, obb, std::placeholders::_1));
  event.Notify("AAAAABBBBB");
  std::cout << "-----------------------" << std::endl;
  event.Detach(key);
  event.Notify("BBBBB");
}

int main() {
  Test();
  return 0;
}

执行输出

|-----------------------------------------------------------------------------------------------------------------------------------------------|
| ObserverA msg: AAAAA ----------------------- ObserverB msg: AAAAABBBBB ObserverA msg: AAAAABBBBB ----------------------- ObserverB msg: BBBBB |

相关推荐
三体世界13 分钟前
TCP传输控制层协议深入理解
linux·服务器·开发语言·网络·c++·网络协议·tcp/ip
你的冰西瓜32 分钟前
C++ 中最短路算法的详细介绍
c++·算法·图论·最短路
随心点儿35 分钟前
使用python 将多个docx文件合并为一个word
开发语言·python·多个word合并为一个
不学无术の码农38 分钟前
《Effective Python》第十三章 测试与调试——使用 Mock 测试具有复杂依赖的代码
开发语言·python
tomcsdn3144 分钟前
SMTPman,smtp的端口号是多少全面解析配置
服务器·开发语言·php·smtp·邮件营销·域名邮箱·邮件服务器
<但凡.1 小时前
数据结构与算法之美:广义表
数据结构·c++·算法
EnigmaCoder1 小时前
Java多线程:核心技术与实战指南
java·开发语言
大白的编程日记.2 小时前
【计算机基础理论知识】C++篇(二)
开发语言·c++·学习
网小鱼的学习笔记3 小时前
python中MongoDB操作实践:查询文档、批量插入文档、更新文档、删除文档
开发语言·python·mongodb
C语言小火车3 小时前
野指针:C/C++内存管理的“幽灵陷阱”与系统化规避策略
c语言·c++·学习·指针