[学习][笔记]设计模式(基于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地址

相关文章
|
7月前
|
设计模式 消息中间件 安全
【JUC】(3)常见的设计模式概念分析与多把锁使用场景!!理解线程状态转换条件!带你深入JUC!!文章全程笔记干货!!
JUC专栏第三篇,带你继续深入JUC! 本篇文章涵盖内容:保护性暂停、生产者与消费者、Park&unPark、线程转换条件、多把锁情况分析、可重入锁、顺序控制 笔记共享!!文章全程干货!
434 1
|
算法 网络安全 区块链
2023/11/10学习记录-C/C++对称分组加密DES
本文介绍了对称分组加密的常见算法(如DES、3DES、AES和国密SM4)及其应用场景,包括文件和视频加密、比特币私钥加密、消息和配置项加密及SSL通信加密。文章还详细展示了如何使用异或实现一个简易的对称加密算法,并通过示例代码演示了DES算法在ECB和CBC模式下的加密和解密过程,以及如何封装DES实现CBC和ECB的PKCS7Padding分块填充。
409 4
2023/11/10学习记录-C/C++对称分组加密DES
|
C++ 开发者
C++学习之继承
通过继承,C++可以实现代码重用、扩展类的功能并支持多态性。理解继承的类型、重写与重载、多重继承及其相关问题,对于掌握C++面向对象编程至关重要。希望本文能为您的C++学习和开发提供实用的指导。
240 16
|
设计模式 Java Kotlin
Kotlin教程笔记(56) - 改良设计模式 - 装饰者模式
Kotlin教程笔记(56) - 改良设计模式 - 装饰者模式
207 2
|
设计模式 安全 Java
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
232 2
|
设计模式 Java Kotlin
Kotlin教程笔记(54) - 改良设计模式 - 迭代器模式
Kotlin教程笔记(54) - 改良设计模式 - 迭代器模式
166 2
|
设计模式 Java API
Kotlin教程笔记(50) - 改良设计模式 - 工厂模式
Kotlin教程笔记(50) - 改良设计模式 - 工厂模式
175 2
|
设计模式 算法 Kotlin
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
186 1
|
设计模式 监控 Java
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
152 1
|
设计模式 安全 Java
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
Kotlin教程笔记(57) - 改良设计模式 - 单例模式