【设计模式|观察者模式】C++

1. 编码

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

/**
 * 观察者接口类
 */
class IObserver {
 public:
  virtual ~IObserver() {};
  virtual void Update(const string& message_from_subject) = 0;
};

/**
 * 发布者接口类
 */
class ISubject {
 public:
  virtual ~ISubject() {};
  virtual void Attach(IObserver* observer) = 0;
  virtual void Detach(IObserver* observer) = 0;
  virtual void Notify() = 0;
};

class Subject : public ISubject {
 public:
  virtual ~Subject() {
    cout << "Goodbye, I was the Subject.\n";
  }

  void Attach(IObserver* observer) override {
    list_observer_.push_back(observer);
  }

  void Detach(IObserver* observer) override {
    list_observer_.remove(observer);
  }

  void Notify() override {
    HowManyObserver();
    for (auto iter = list_observer_.begin(); iter != list_observer_.end(); ++iter) {
      (*iter)->Update(message_);
    }
  }

  void CreateMessage(string message = "Empty") {
    message_ = message;
    Notify();
  }

  void HowManyObserver() {
    cout << "There are " << list_observer_.size() << " observers in the list.\n";
  }

  void SomeBussinessLogic() {
    message_ = "Change message message";
    Notify();
    cout << "I'm about to do some thing important\n";
  }
 private:
  list<IObserver*> list_observer_; //关键链表，存放所有订阅者
  string message_;
};

class Observer : public IObserver {
 public:
  Observer(Subject& subject) : subject_(subject) {
    subject_.Attach(this);
    cout << "Hi, I'm the obsever \"" << ++Observer::static_number_ << "\".\n";
    number_ = Observer::static_number_;
  }

  virtual ~Observer() {
    cout << "Goodbye, I was the Observer \"" << number_ << "\".\n";
  }

  void Update(const string &message_from_subject) override {
    message_from_subject_ = message_from_subject;
    PrintInfo();
  }

  void RemoveMeFromTheList() {
    subject_.Detach(this);
    cout << "Observer \"" << number_ << "\" removed from the list.\n";
  }
  void PrintInfo() {
    cout << "Observer \"" << number_ << "\": a new message is available -->" << message_from_subject_ << endl;
  }
 private:
  string message_from_subject_;
  Subject& subject_; //订阅者的引用
  static int static_number_; //已订阅数量
  int number_; //订阅者序号
};

int Observer::static_number_ = 0;

void ClientCode() {
  Subject* subject = new Subject();
  Observer* observer1 = new Observer(*subject);
  Observer* observer2 = new Observer(*subject);
  Observer* observer3 = new Observer(*subject);
  Observer* observer4;
  Observer* observer5;

  subject->CreateMessage("Hello World! :D");
  
  observer3->RemoveMeFromTheList();
  subject->CreateMessage("The weather is hot today! :p");
  
  observer4 = new Observer(*subject);
  observer2->RemoveMeFromTheList();
  observer5 = new Observer(*subject);
  subject->CreateMessage("My new car is great! :)");
  
  observer5->RemoveMeFromTheList();
  observer4->RemoveMeFromTheList();
  observer1->RemoveMeFromTheList();

  delete observer5;
  delete observer4;
  delete observer3;
  delete observer2;
  delete observer1;
  delete subject;
}

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

输出：

Hi, I'm the obsever "1".
Hi, I'm the obsever "2".
Hi, I'm the obsever "3".
There are 3 observers in the list.
Observer "1": a new message is available -->Hello World! :D
Observer "2": a new message is available -->Hello World! :D
Observer "3": a new message is available -->Hello World! :D
Observer "3" removed from the list.
There are 2 observers in the list.
Observer "1": a new message is available -->The weather is hot today! :p
Observer "2": a new message is available -->The weather is hot today! :p
Hi, I'm the obsever "4".
Observer "2" removed from the list.
Hi, I'm the obsever "5".
There are 3 observers in the list.
Observer "1": a new message is available -->My new car is great! :)
Observer "4": a new message is available -->My new car is great! :)
Observer "5": a new message is available -->My new car is great! :)
Observer "5" removed from the list.
Observer "4" removed from the list.
Observer "1" removed from the list.
Goodbye, I was the Observer "5".
Goodbye, I was the Observer "4".
Goodbye, I was the Observer "3".
Goodbye, I was the Observer "2".
Goodbye, I was the Observer "1".
Goodbye, I was the Subject.

2. 分析

基本概念：一种行为设计模式，允许你定义一种订阅机制，可以在对象事件发生时通知多个“观察”该对象的其他对象

C++实现关键点：

• 为发布者和订阅者分别定义接口
• 具体发布者至少需要定义：增加订阅者，删除订阅者，通知所有订阅者，存放所有订阅者的链表（增删快速），以及其他核心逻辑
• 具体订阅者至少需要定义：构造函数（将新生成的对象自动订阅发布者），受到发布者通知后的响应函数，从发布者列表移除自己的函数，订阅者的引用（组合）