[学习][笔记]设计模式(基于C/C++实现)<二>观察者模式

简介: [学习][笔记]设计模式(基于C/C++实现)<二>观察者模式

前言

观察者模式

定义

观察者模式,又可以称之为发布-订阅模式,观察者,顾名思义,就是一个监听者,类似监听器的存在,一旦被观察/监听的目标发生的情况,就会被监听者发现,这么想来目标发生情况到观察者知道情况,其实是由目标将情况发送到观察者的。

观察对象的状态发生变化时,通知给观察者。

使用场景

观察者模式适用于根据对象状态进行相应处理的场景。

观察者模式多用于实现订阅功能的场景,例如微博的订阅,当我们(Observer)订阅了某个人(Subject)的微博账号,当这个人发布(Action)了新的消息,就会通知(Notify)我们。

基本思路

1.创建被观察的主体(Subject),和观察者(Observer)

2.观察者(Observer)订阅(attach)主体(Subject).

3.主体状态变化(action),通知(notify)所有观察者(Observer)采取措施(update)

实例

秘书等老板回来就同志各个划水的同志停止划水,有看nba的同志,有看股票的同志。

//observer.h
#ifndef OBSERVER_H
#define OBSERVER_H
#include <string>
class Subject;
//抽象观察者
class Observer
{
protected:
    std::string name;
    Subject *sub;
public:
    Observer(std::string name, Subject *sub)
    {
        this->name = name;
        this->sub = sub;
    }
    virtual void update() = 0;
};
#endif // OBSERVER_H
//subject.h
#ifndef SUBJECT_H
#define SUBJECT_H
#include <list>
#include <string>
class Observer;
//抽象通知者(主体)
class Subject
{
protected:
    std::list<Observer*> observers;
public:
    std::string action;
    virtual void attach(Observer*) = 0;
    virtual void detach(Observer*) = 0;
    virtual void notify() = 0;
};
#endif // SUBJECT_H
//subject_sercretary.h
#ifndef SUBJECT_SERCRETARY_H
#define SUBJECT_SERCRETARY_H
#include <subject.h>
#include <list>
#include <observer.h>
//秘书
class Secretary :public Subject
{
    void attach(Observer *observer)
    {
        observers.push_back(observer);
    }
    void detach(Observer *observer)
    {
        std::list<Observer *>::iterator iter = observers.begin();
        while (iter != observers.end())
        {
            if ((*iter) == observer)
            {
                observers.erase(iter);
            }
            ++iter;
        }
    }
    void notify()
    {
        std::list<Observer *>::iterator iter = observers.begin();
        while (iter != observers.end())
        {
            (*iter)->update();
            ++iter;
        }
    }
};
#endif // SUBJECT_SERCRETARY_H
//observer_nba.h
#ifndef OBSERVER_NBA_H
#define OBSERVER_NBA_H
#include <string>
#include <observer.h>
#include <iostream>
#include <subject.h>
class Subject;
using namespace std;
//具体的观察者,看NBA的
class NBAObserver :public Observer
{
public:
    NBAObserver(std::string name, Subject *sub) :Observer(name, sub)
    {
    }
    void update();
};
void NBAObserver::update()
{
    cout << name << " 收到消息:" << sub->action << endl;
    if (sub->action == "梁所长来了!")
    {
        cout << "我马上关闭NBA,装做很认真工作的样子!" << endl;
    }
}
#endif // OBSERVER_NBA_H
//observer_stock.h
#ifndef OBSERVER_STOCK_H
#define OBSERVER_STOCK_H
#include <string>
#include <observer.h>
#include <subject.h>
#include <iostream>
//具体的观察者,看股票的
class StockObserver :public Observer
{
public:
    StockObserver(std::string name, Subject *sub) :Observer(name, sub)
    {
    }
    void update();
};
void StockObserver::update()
{
    std::cout << name << " 收到消息:" << sub->action << std::endl;
    if (sub->action == "梁所长来了!")
    {
        std::cout << "我马上关闭股票,装做很认真工作的样子!" << std::endl;
    }
}
#endif // OBSERVER_STOCK_H
//main.cpp
#include <iostream>
#include <string>
#include <list>
#include <observer_nba.h>
#include <observer_stock.h>
#include <subject.h>
#include <subject_sercretary.h>
using namespace std;
int main()
{
    Subject *dwq = new Secretary(); //创建观察者<br>    //被观察的对象
    Observer *xs = new NBAObserver("xiaoshuai", dwq);
    Observer *zy = new NBAObserver("zouyue", dwq);
    Observer *lm = new StockObserver("limin", dwq);
    //加入观察队列
    dwq->attach(xs);
    dwq->attach(zy);
    dwq->attach(lm);
    //事件
    dwq->action = "去吃饭了!";
    dwq->notify();
    cout << endl;
    dwq->action = "梁所长来了!";
    dwq->notify();
    return 0;
}
输出:
xiaoshuai 收到消息:去吃饭了!
zouyue 收到消息:去吃饭了!
limin 收到消息:去吃饭了!
xiaoshuai 收到消息:梁所长来了!
我马上关闭NBA,装做很认真工作的样子!
zouyue 收到消息:梁所长来了!
我马上关闭NBA,装做很认真工作的样子!
limin 收到消息:梁所长来了!
我马上关闭股票,装做很认真工作的样子!

总结

demo地址

目录
打赏
0
0
0
0
44
分享
相关文章
Kotlin - 改良设计模式 - 观察者模式
Kotlin - 改良设计模式 - 观察者模式
68 3
前端必须掌握的设计模式——观察者模式
观察者模式(Observer Pattern)是一种行为型设计模式,实现了一种订阅机制。它包含两个角色:**观察者**(订阅消息、接收通知并执行操作)和**被观察者**(维护观察者列表、发送通知)。两者通过一对多的关系实现解耦,当被观察者状态改变时,会通知所有订阅的观察者。例如,商店老板作为被观察者,记录客户的需求并在商品到货时通知他们。前端应用中,如DOM事件注册、MutationObserver等也体现了这一模式。
|
2月前
|
C++学习之继承
通过继承,C++可以实现代码重用、扩展类的功能并支持多态性。理解继承的类型、重写与重载、多重继承及其相关问题,对于掌握C++面向对象编程至关重要。希望本文能为您的C++学习和开发提供实用的指导。
65 16
2023/11/10学习记录-C/C++对称分组加密DES
本文介绍了对称分组加密的常见算法(如DES、3DES、AES和国密SM4)及其应用场景,包括文件和视频加密、比特币私钥加密、消息和配置项加密及SSL通信加密。文章还详细展示了如何使用异或实现一个简易的对称加密算法,并通过示例代码演示了DES算法在ECB和CBC模式下的加密和解密过程,以及如何封装DES实现CBC和ECB的PKCS7Padding分块填充。
74 4
2023/11/10学习记录-C/C++对称分组加密DES
Kotlin教程笔记(56) - 改良设计模式 - 装饰者模式
Kotlin教程笔记(56) - 改良设计模式 - 装饰者模式
52 2
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
44 2
Java 设计模式——观察者模式:从优衣库不使用新疆棉事件看系统的动态响应
【11月更文挑战第17天】观察者模式是一种行为设计模式,定义了一对多的依赖关系,使多个观察者对象能直接监听并响应某一主题对象的状态变化。本文介绍了观察者模式的基本概念、商业系统中的应用实例,如优衣库事件中各相关方的动态响应,以及模式的优势和实际系统设计中的应用建议,包括事件驱动架构和消息队列的使用。
Kotlin教程笔记(54) - 改良设计模式 - 迭代器模式
Kotlin教程笔记(54) - 改良设计模式 - 迭代器模式
61 2
Kotlin教程笔记(50) - 改良设计模式 - 工厂模式
Kotlin教程笔记(50) - 改良设计模式 - 工厂模式
62 2
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
62 1
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等