C++ 设计模式之观察者模式

【声明】本题目来源于卡码网(题目页面 (kamacoder.com))

【提示:如果不想看文字介绍,可以直接跳转到C++编码部分】


【设计模式大纲】

C++ 设计模式之观察者模式_第1张图片

         前面的文章介绍了创建型模式和结构型模式,今天开始介绍行为型模式。


【简介】什么是观察者模式(第13种模式)

        观察者模式(发布-订阅模式)属于⾏为型模式,定义了⼀种⼀对多的依赖关系,让多个观察者对象同时监听⼀个主题对象,当主题对象的状态发⽣变化时,所有依赖于它的观察者都得到通知并被⾃动更新。
        观察者模式依赖两个模块:

  • Subject (主题):也就是被观察的对象,它可以维护⼀组观察者,当主题本身发⽣改变时就会通知观察者。
  • Observer (观察者):观察主题的对象,当“被观察”的主题发⽣变化时,观察者就会得到通知并执⾏相应的处理。

 

        使⽤观察者模式有很多好处,⽐如说观察者模式将主题和观察者之间的关系解耦,主题只需要关注⾃⼰的状态变化,⽽观察者只需要关注在主题状态变化时需要执⾏的操作,两者互不⼲扰,并且由于观察者和主题是相互独⽴的,可以轻松的增加和删除观察者,这样实现的系统更容易扩展和维护。


【基本结构】

        观察者模式依赖主题和观察者,但是⼀般有4个组成部分:

C++ 设计模式之观察者模式_第2张图片

  •  主题Subject : ⼀般会定义成⼀个接⼝,提供⽅法⽤于注册、删除和通知观察者,通常也包含⼀个状态,当状态发⽣改变时,通知所有的观察者。
  • 观察者Observer : 观察者也需要实现⼀个接⼝,包含⼀个更新⽅法,在接收主题通知时执⾏对应的操作。
  • 具体主题ConcreteSubject : 主题的具体实现, 维护⼀个观察者列表,包含了观察者的注册、删除和通知⽅法。
  • 具体观察者ConcreteObserver : 观察者接⼝的具体实现,每个具体观察者都注册到具体主题中,当主题状态变化并通知到具体观察者,具体观察者进⾏处理。

 【基本实现】

        根据上⾯的类图,我们可以写出观察者模式的基本实现(以Java代码作以说明):

1. 主题接口

// 主题接⼝ (主题)
interface Subject {
    // 注册观察者
    void registerObserver(Observer observer);
    // 移除观察者
    void removeObserver(Observer observer);
    // 通知观察者
    void notifyObservers();
}

2. 观察者接口

// 观察者接⼝ (观察者)
interface Observer {
    // 更新⽅法
    void update(String message);
}

3. 具体主题的实现

// 具体主题实现
class ConcreteSubject implements Subject {
    // 观察者列表
    private List observers = new ArrayList<>();
    // 状态
    private String state;
    // 注册观察者
    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }
    // 移除观察者
    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
    // 通知观察者
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
        // 观察者根据传递的信息进⾏处理
        observer.update(state);
        }
    }
    // 更新状态
    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }
}

4. 具体观察者的实现

// 具体观察者实现
class ConcreteObserver implements Observer {
    // 更新⽅法
    @Override
    public void update(String message) {
    }
}

【使用场景】

        观察者模式特别适⽤于⼀个对象的状态变化会影响到其他对象,并且希望这些对象在状态变化时能够⾃动更新的情况。 ⽐如说在图形⽤户界⾯中,按钮、滑动条等组件的状态变化可能需要通知其他组件更新,这使得观察者模式被⼴泛应⽤于GUI框架,⽐如Java的Swing框架。
        此外,观察者模式在前端开发和分布式系统中也有应⽤,⽐较典型的例⼦是前端框架Vue , 当数据发⽣变化时,视图会⾃动更新。⽽在分布式系统中,观察者模式可以⽤于实现节点之间的消息通知机制,节点的状态变化将通知其他相关节点。


【编码部分】

1. 题目描述

        小明所在的学校有一个时钟(主题),每到整点时,它就会通知所有的学生(观察者)当前的时间,请你使用观察者模式实现这个时钟通知系统。

        注意点:时间从 0 开始,并每隔一个小时更新一次。

2. 输入描述

        输入的第一行是一个整数 N(1 ≤ N ≤ 20),表示学生的数量。 接下来的 N 行,每行包含一个字符串,表示学生的姓名。 最后一行是一个整数,表示时钟更新的次数。

3. 输出描述

        对于每一次时钟更新,输出每个学生的姓名和当前的时间。

4. C++编码实例

/**
* @version Copyright (c) 2024 NCDC, Servo。 Unpublished - All rights reserved
* @file ObserverMode.hpp
* @brief 观察者模式
* @autor 写代码的小恐龙er
* @date 2024/01/15
*/

#include 
#include 
#include 

using namespace std;

// 前置声明

// 观察者接口类(再次声明 接口类都是属于基类  需要后续具体实现类来重载操作)
class Observer;
// 主题接口
class Subject;
// 具体主题的实现 -- 时钟
class Clock;
// 具体的观察者 -- 学生
class Student;

// 观察者接口类
class Observer
{
// 接口函数 -- 更新主题的变化
public:
    Observer(){}
    virtual void UpdateTime(int hour) = 0;
};

// 主题接口
class Subject
{
// 主题对观察者的接口函数
public:
    Subject(){}
    // 注册(添加)观察者
    virtual void AddObserver(Observer *observer) = 0;
    // 移除观察者
    virtual void RemoveObserver(Observer *observer) = 0;
    // 通知所有观察者
    virtual void NotifyObservers() = 0;
};


// 具体主题的实现 -- 时钟
class Clock : public Subject
{
// 成员数据
private:
    std::vector _observers;
    int hourTime = 0;

// 成员函数
public:
    // 重载添加函数
    void AddObserver(Observer *observer) override {
        this->_observers.push_back(observer);
    }
    // 重载移除函数
    void RemoveObserver(Observer *observer) override{
        for(unsigned int i = 0; i < _observers.size(); i++){
            if(this->_observers[i] == observer){
                delete this->_observers[i];
                this->_observers[i] = nullptr;
            }
        }
    }
    // 重载通知函数
    void NotifyObservers() override{
        for(Observer *observer : this->_observers){
            observer->UpdateTime(this->hourTime);
        }
    }
    
    // 模拟时间的推移
    void TimeRun(){
        this->hourTime = (this->hourTime + 1);
        NotifyObservers();
    }
    
};

// 具体的观察者 -- 学生
class Student : public Observer
{
// 成员数据
private:
    string _name;

// 成员函数 
public:
    // 重载构造函数 -- 利用学生姓名来具体实例化学生类
    Student(string name){
        this->_name = name;
    }
    
    // 重载更新时间函数
    void UpdateTime(int hour) override {
        std::cout << _name << " " << hour << endl;
    }
};


// 客户端代码
int main()
{
    // 学生数量
    int stuNum = 0;
    // 输入
    std::cin >> stuNum;
    // 创建具体主题 -- 时钟类
    Clock * clocker = new Clock();
    // 创建学生类 -- 用基类创建
    Observer * student = nullptr;
    // 学生姓名
    string name = "";
    // 输入
    int i = 0;
    for(i = 0; i < stuNum; i++)
    {
        std::cin >>  name;
        // 创建学生
        student = new Student(name);
        // 添加学生
        clocker->AddObserver(student);
    }
    
    // 时钟更新次数
    int updateNum = 0;
    // 输入
    std::cin >> updateNum;
    
    for(i = 0; i < updateNum; i++){
        //  调用时间推移函数
        clocker->TimeRun();
    }
    
    // 析构
    if(student != nullptr){
        delete student;
        student = nullptr;
    }
    delete clocker;
    clocker = nullptr;
    
    return 0;
}



......

To be continued.

你可能感兴趣的:(c++,设计模式,观察者模式)