《大话设计模式》C++实现：14 观察者模式（一）

最新推荐文章于 2022-07-19 11:25:36 发布
最新推荐文章于 2022-07-19 11:25:36 发布
阅读量263 收藏 1
点赞数
分类专栏： 《大话设计模式》 文章标签： 大话设计模式 观察者模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29567701/article/details/107242879
版权

文章目录

1、什么是观察者模式？

观察者模式，又称 “发布-订阅” （Publish-Subscribe）模式。
观察者模式，定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主体对象。这个主体对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

2、为何要使用观察者模式？

1、为了解耦。让耦合的双方都依赖于抽象，而不是依赖于具体，从而使得各自的变化都不会影响另一边的变化。同时也满足"依赖倒转" 原则：让程序都依赖抽象，而不是相互依赖。
2、使用观察者模式的动机：
将一个系统分割成一系列互相协作的类有一个很不好的副作用：需要维护相关对象间的一致性。
我们不希望为了维护一致性而使得各类紧密耦合，这样，会给维护、扩展和重用都带来不便。
3、使用场景
（1）当一个对象的改变需要同时改变其他对象，且他不知道具体有多少个对象有待改变时，应该考虑使用观察者模式。
（2）换言之，一个抽象模型有两个方面，其中一方面依赖于另一方面，此时，用观察者模式可以将这两者凡转载独立的对象中，使他们各自独立地改变和复用。

3、如何才能用好观察者模式？

需要练习。。。

4、怎样使用观察者模式？
4.1 观察者模式的演进
  1. 双向耦合
    在这里插入图片描述
  2. 单向解耦（解耦 具体观察者与 通知者）
    在这里插入图片描述
  3. 双向解耦（解耦 具体观察者 与 具体通知者）
    （1）ISubject类：把所有观察者对象的引用（或指针），保存在一个聚集里，每个主题都可以有任何数量的观察者。 抽象主题提供一个接口，可以增加和删除观察者对象。
    （2）IObserver类：抽象观察者，为所有具体观察者定义一个接口，在得到主题的通知时，更新自己。
    （3）ConcreteSubject类：具体主题，将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。
    （4）ConcreteObserver类：具体观察者，实现抽象观察者角色所要求的更新接口，一遍使本身的状态与主题的状态相协调/一致。
    在这里插入图片描述
5、实例

1、双向耦合

1.1.1 Secretary.h

#pragma once
#include <list>
#include <string>
#include "StockObserver.h"
using namespace std;

class StockObserver;

class Secretary
{
public:
	Secretary();
	Secretary(const string& act) :m_sAction(act) {}
	~Secretary();
public:
	//增加
	void attach(StockObserver* observer);
	//通知
	void notify();
	//前台状态
	string getAction();
	void setAction(const string& _action);
private:
	//同事列表
	list<StockObserver* > m_observers;
	//前台状态
	string m_sAction;
};

1.1.2 Secretary.cpp

#include "Secretary.h"


Secretary::Secretary()
{
}

Secretary::~Secretary()
{
}

void Secretary::attach(StockObserver* observer)
{
	m_observers.push_back(observer);
}

void Secretary::notify()
{
	for each (StockObserver* observer in m_observers)
	{
		observer->update();
	}
}

std::string Secretary::getAction()
{
	return m_sAction;
}

void Secretary::setAction(const string& _action)
{
	m_sAction = _action;
}

1.2.1 StockObserver.h

#pragma once
#include <list>
#include <string>
#include "Secretary.h"
using namespace std;

class Secretary;
class StockObserver
{
public:
	StockObserver();
	StockObserver(const string& name, Secretary* sub);
	void update();
private:
	string m_name;
	Secretary* m_sub;
};

1.2.2 StockObserver.cpp

#include "StockObserver.h"
#include <iostream>


StockObserver::StockObserver()
{
}


StockObserver::StockObserver(const string& name, Secretary* sub)
	: m_name(name), m_sub(sub)
{

}

void StockObserver::update()
{
	//err: getAction没起作用，不知道原因！！
	//还真是需要指针，指针指的对象永远可以知晓
	cout << m_sub->getAction() << "," << m_name << ", 关闭股票行情，继续工作！" << endl;
}

1.3 main.cpp

#include<iostream>
#include "Secretary.h"
#include "StockObserver.h"

int main()
{
	Secretary* pSecretary = new Secretary();

	StockObserver* pObserver1 = new StockObserver("小白", pSecretary);
	StockObserver* pObserver2 = new StockObserver("小黄", pSecretary);

	pSecretary->attach(pObserver1);
	pSecretary->attach(pObserver2);

	pSecretary->setAction("老板回来了");
	pSecretary->notify();

	//析构指针对象
	delete pSecretary;
	pSecretary = nullptr;
	
	delete pObserver1;
	pObserver1 = nullptr;
	delete pObserver2;
	pObserver2 = nullptr;

	system("pause");
	return 0;
}
//此种模式，
//双向耦合（Secretary依赖StockObserver，且StockObserver同时也依赖Secretary），不好！！

在这里插入图片描述
2、单向解耦（解耦 具体观察者与 通知者）
2.1.1 IObserver.h

#pragma once

#include <list>
#include <string>
#include "Secretary.h"
class Secretary;
using namespace std;

class IObserver
{
public:
	IObserver();
	IObserver(const string& name, Secretary* sub);
	virtual void update() = 0;
protected:
	string m_name;
	Secretary* m_sub;
};

2.1.2 IObserver.cpp

#include "IObserver.h"

IObserver::IObserver()
{
}

IObserver::IObserver(const string& name, Secretary* sub)
	:m_name(name), m_sub(sub)
{

}

2.2.1 StockObserver.h

#pragma once
#include <list>
#include <string>
#include "IObserver.h"
using namespace std;

class Secretary;
class StockObserver :public IObserver
{
public:
	StockObserver();
	StockObserver(const string& name, Secretary* sub);
	void update();
};

2.2.2 StockObserver.cpp

#include "StockObserver.h"
#include <iostream>


StockObserver::StockObserver()
{
}


StockObserver::StockObserver(const string& name, Secretary* sub)
	: IObserver(name, sub)
{

}

void StockObserver::update()
{
	//err: getAction没起作用，不知道原因！！
	//还真是需要指针，指针指的对象永远可以知晓
	cout << m_sub->getAction() << "," << m_name << ", 关闭股票行情，继续工作！" << endl;
}

2.3.1 NBAObserver.h

#pragma once
#include "IObserver.h"
class NBAObserver :
	public IObserver
{
public:
	NBAObserver();
	NBAObserver(const string& name, Secretary* sub);
	virtual void update() override;
};

2.3.2 NBAObserver.cpp

#include "NBAObserver.h"
#include <iostream>


NBAObserver::NBAObserver()
{
}


NBAObserver::NBAObserver(const string& name, Secretary* sub)
	:IObserver(name, sub)
{

}

void NBAObserver::update()
{
	cout << m_sub->getAction() << "," << m_name << ", 关闭NBA直播，继续工作！" << endl;
}

2.4.1 Secretary.h

#pragma once
#include <list>
#include <string>
#include "IObserver.h"
using namespace std;

class IObserver;
class Secretary
{
public:
	Secretary();
	Secretary(const string& act) :m_sAction(act) {}
public:
	//增加
	void attach(IObserver* observer);
	void detach(IObserver* observer);
	//通知
	void notify();
	//前台状态
	string getAction();
	void setAction(const string& _action);
private:
	//同事列表
	list<IObserver* > m_observers;
	//前台状态
	string m_sAction;
};

2.4.2 Secretary.cpp

#include "Secretary.h"


Secretary::Secretary()
{
}

void Secretary::attach(IObserver* observer)
{
	m_observers.push_back(observer);
}

void Secretary::detach(IObserver* observer)
{
	m_observers.remove(observer);
	delete observer;
	observer = nullptr;
}

void Secretary::notify()
{
	for each (IObserver* observer in m_observers)
	{
		observer->update();
	}
}

std::string Secretary::getAction()
{
	return m_sAction;
}

void Secretary::setAction(const string& _action)
{
	m_sAction = _action;
}

2.5 main.cpp

#include<iostream>
#include "Secretary.h"
#include "StockObserver.h"
#include "NBAObserver.h"

void test2()
{
	cout << "==============test2()=================" << endl;
	Secretary* pSecretary = new Secretary();
	StockObserver* pObserver1 = new StockObserver("小白", pSecretary);
	NBAObserver* pObserver2 = new NBAObserver("小黄", pSecretary);

	pSecretary->attach(pObserver1);
	pSecretary->attach(pObserver2);

	pSecretary->setAction("Leo回来了");
	pSecretary->notify();

	//析构指针对象
	delete pSecretary;
	pSecretary = nullptr;

	delete pObserver1;
	pObserver1 = nullptr;
	delete pObserver2;
	pObserver2 = nullptr;
}
//此种模式，
//也存在耦合
//有一点改进：观察者稍稍解耦，可以拓展任意多个观察者

int main()
{
	test2();
	system("pause");
	return 0;
}

在这里插入图片描述
3、双向解耦（解耦 具体观察者 与 具体通知者）
3.1.1 IObserver.h

#pragma once

#include <list>
#include <string>
#include "ISubject.h"
class ISubject;
using namespace std;

class IObserver
{
public:
	IObserver();
	IObserver(const string& name, ISubject* sub);
	virtual void update() = 0;
protected:
	string m_name;
	ISubject* m_sub;
};

3.1.2 IObserver.cpp

#include "IObserver.h"
IObserver::IObserver()
{
}


IObserver::IObserver(const string& name, ISubject* sub)
	:m_name(name), m_sub(sub)
{

}

3.2.1 StockObserver .h

#pragma once
#include <list>
#include <string>
#include "IObserver.h"
using namespace std;

class Secretary;
class StockObserver :public IObserver
{
public:
	StockObserver();
	StockObserver(const string& name, ISubject* sub);
	void update()override;
};

3.2.2 StockObserver .cpp

#include "StockObserver.h"
#include <iostream>


StockObserver::StockObserver()
{
}


StockObserver::StockObserver(const string& name, ISubject* sub)
	: IObserver(name, sub)
{

}

void StockObserver::update()
{
	//err: getAction没起作用，不知道原因！！
	//还真是需要指针，指针指的对象永远可以知晓
	cout << m_sub->getAction() << "," << m_name << ", 关闭股票行情，继续工作！" << endl;
}

3.3.1 NBAObserver .h

#pragma once
#include "IObserver.h"
class NBAObserver :
	public IObserver
{
public:
	NBAObserver();
	NBAObserver(const string& name, ISubject* sub);
	virtual void update() override;
};

3.3.1 NBAObserver .cpp

#include "NBAObserver.h"
#include <iostream>


NBAObserver::NBAObserver()
{
}


NBAObserver::NBAObserver(const string& name, ISubject* sub)
	:IObserver(name, sub)
{

}

void NBAObserver::update()
{
	cout << m_sub->getAction() << "," << m_name << ", 关闭NBA直播，继续工作！" << endl;
}

3.4 ISubject.h

#pragma once
#include "IObserver.h"
#include <string>
using namespace std;

class IObserver;
class ISubject
{
public:
	virtual void attach(IObserver* observer) = 0;
	virtual void detach(IObserver* observer) = 0;
	virtual void notify() = 0;
	virtual string getAction() = 0;
	virtual void setAction(const string& action) = 0;
};

3.5.1 Secretary.h

#pragma once
#include "ISubject.h"
#include <list>

class IObserver;
class Secretary :public ISubject
{
public:
	Secretary();
	Secretary(const string& act) :m_sAction(act) {}
public:
	//增加
	void attach(IObserver* observer) override;
	void detach(IObserver* observer) override;
	//通知
	void notify() override;
	//前台状态
	string getAction() override;
	void setAction(const string& _action) override;
private:
	//同事列表
	list<IObserver* > m_observers;
	//前台状态
	string m_sAction;
};

3.5.1 Secretary.cpp

#include "Secretary.h"


Secretary::Secretary()
{
}

void Secretary::attach(IObserver* observer)
{
	m_observers.push_back(observer);
}

void Secretary::detach(IObserver* observer)
{
	m_observers.remove(observer);
	delete observer;
	observer = nullptr;
}

void Secretary::notify()
{
	for each (IObserver* observer in m_observers)
	{
		observer->update();
	}
}

std::string Secretary::getAction()
{
	return m_sAction;
}

void Secretary::setAction(const string& _action)
{
	m_sAction = _action;
}

3.6.1 Boss .h

#pragma once
#include "ISubject.h"
#include <list>

class Boss :
	public ISubject
{
public:
	Boss();

	virtual void attach(IObserver* observer) override;


	virtual void detach(IObserver* observer) override;


	virtual void notify() override;


	virtual string getAction() override;


	virtual void setAction(const string& action) override;

private:
	list<IObserver* > m_observers;
	string m_action;
};

3.6.2 Boss .cpp

#include "Boss.h"



Boss::Boss()
{
}

void Boss::attach(IObserver* observer)
{
	m_observers.push_back(observer);
}

void Boss::detach(IObserver* observer)
{
	m_observers.remove(observer);
}

void Boss::notify()
{
	for each (IObserver* observer in m_observers)
	{
		observer->update();
	}
}

std::string Boss::getAction()
{
	return m_action;
}

void Boss::setAction(const string& action)
{
	m_action = action;
}

3.7 main.cpp

#include<iostream>
#include "Secretary.h"
#include "StockObserver.h"
#include "NBAObserver.h"
#include "Boss.h"

void test3()
{
	cout << "==============test3()=================" << endl;
	Boss* pBoss = new Boss();
	StockObserver* pObserver1 = new StockObserver("小白", pBoss);
	NBAObserver* pObserver2 = new NBAObserver("小黄", pBoss);

	pBoss->attach(pObserver1);
	pBoss->attach(pObserver2);

	pBoss->setAction("May I come in ?");
	pBoss->notify();

	//析构指针对象
	delete pBoss;
	pBoss = nullptr;

	delete pObserver1;
	pObserver1 = nullptr;
	delete pObserver2;
	pObserver2 = nullptr;
}
//实现了 具体观察者与具体通知者的 解耦
//之后可以随便扩展 通知者，随便扩展观察者，且每个通知者都可以与私下里与任意观察者交易，绑定与解绑，由每个通知者自己意愿决定

int main()
{
	test3();
	system("pause");
	return 0;
}

在这里插入图片描述

此为《大话设计模式》学习心得系列 P123~~

东篱_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 14观察者模式
sky0942的博客
12-10 436
观察者模式又叫发布-订阅（Publish/Subscribe）模式。   观察者模式的定义： 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主体对象在状态发生改变时，会通知所有观察者对象，使它们能够自动更新自己。 观察者模式结构图如下： Subject类，它把所有对观察者对象的引用保存在一个列表（list或vector）里，每个主题都可以有
大话设计模式C++实现-第14章-观察者模式
西青年·部落格
12-21 1959
一、UML图 二、概念 观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。 三、说明 角色： （1）Subject类：可以翻译为主题或者抽象通知者，一般用一个抽象类或者一个接口实现。他把所有对观察者对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接
C++单线程和多线程下的观察者模式
大草的博客
01-31 1651
C++单线程和多线程下的观察者模式
线程安全的观察者模式
蓬蒿雪人⛄️的博客
04-06 440
线程安全的观察者模式实现
线程安全的观察者模式（智能指针）
weixin_44403747的博客
01-09 2892
与其他面向对象语言不同，C++要求程序员自己去管理对象的生命周期，这就意味着我们总是需要去关注对象的销毁，尤其是在多线程的环境下对象的析构函数编写变得尤为困难，所以在这个方面需要下很大的功夫，否则用C++编写的程序将有很有很多bug。 当异构函数遇到多线程 在阅读文章之前我先提出两个问题： 在析构一个对象的时候，从何而知此时是否有别的线程正在执行该对象的成员函数？ 调用某个对象的成员函数之前，如何知道对象还活着？它的析构函数会不会碰巧执行到一半？ 这些问题是多线程编程面临的基本问题，本文将从这些问
设计模式系列（大话设计模式c++版）——观察者模式
月照大江流的博客
07-16 384
设计模式系列（大话设计模式c++版）——观察者模式模式定义模式特点模式实现 模式定义 让我们来看看《大话设计模式》这本书中对于观察者模式的定义：其又叫发布—订阅模式，定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当这个主题对象在状态发生变化时，会通知所有的观察者对象，是他们可以随之自动更新自己的状态。 其组成大概分为至少4个部分：观察者接口、发布者接口、一般是1个发布者、不止一个的观察者 模式特点 将一个系统分割成一系列相互协作的类，同时又需要维护类间的一致性，观察者模式可以避免各类
大话设计模式 —— 第十四章《观察者模式》C++ 代码实现
TAOTAO
04-14 259
目录 定义 结构 优点 缺点 适用场景 定义 观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象对象同时监视某一个主题对象。这个主题对象的状态变化时，会通知所有的观察者对象，使他们能够自动更新自己的状态。 举个例子：观察者模式可以理解为, 在一个一对多的关系模式中, 例如一个微信公众号有多...
设计模式之《大话设计模式》.pptx
10-31
设计模式之《大话设计模式》.pptx
C++设计模式之建造者模式
01-20
建造者模式 在GOF的《设计模式 可复用面向对象软件的基础》中是这样说的：将一个复杂对象的构建与它的表示分离，使得同样的...在《大话设计模式》一书中，例举了一个很好的例子————建造小人。建造一个小人，要分为
大话设计模式-完整设计模式介绍
10-23
大话设计模式 完整设计模式介绍
【资源免费下载】Java代码积累丨大话设计模式（Java实现版本）、线程协作
10-31
设计模式参考《大话设计模式》 工厂简单模式 创造型模式 工厂方法模式 抽象工厂模式 原型模式 建造者模式 单例模式 结构型模式 队列模式 桥接模式 组合模式 装饰模式 外观模式 享元模式 代理模式 行为模式（类行为...
《大话设计模式》Java版的实现案例源码.zip
最新发布
02-20
《大话设计模式》Java版的实现案例源码.zip
14 大话设计模式C++实现之观察者模式
Woosual的博客
01-09 187
/* 观察者模式（又叫发布-订阅模式）定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。 这个主题对象在状态发生变化时会通知所有的观察者对象 */ /* 例子：有员工在上班时间看电影、NBA、股票等与工作无关的内容，前台可以给员工发送通知，因此所有的员工通过监听受监测对象即可对自身的工作做出调整 同样的，老板也需要通知一些业务内容，因此例子主要让在干不同事的员工监听前台类和...
在C++11中实现监听者模式
weixin_34393428的博客
11-11 708
参考文章：https://coderwall.com/p/u4w9ra/implementing-signals-in-c-11 最近在完成C++大作业时，碰到了监听者模式的需求。 尽管C++下也可以通过声明IObserver这样的接口，做继承，然后实现类似Java中的监听者模式。 但是这种方法并不是最适合C++的。通过利用C++11中的函数对象和RAII，我们可以实现一个更符合C++国情的监听者...
GOF23种设计模式C++版本
小胖七少爷的博客
07-19 743
GOF设计模式，C++实现
设计模式C++实现（15）——观察者模式
热门推荐
wuzhekai的专栏
08-10 5万+
软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。最近看设计模式的书，对于每个模式，用C++写了个小例子，加深一下理解。主要参考《大
【IOC框架】分析与理解
weixin_34153893的博客
02-01 3863
1 IoC理论的背景我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。图1：软件系统中耦合的对象如果我们打开机械式手表的后盖，就会看到与上面类似的情形，各个齿轮分别带动时针、分针和秒针顺时针旋转，从而在表盘上产生正确的时间。图1中描述的就是这样的一个齿轮组，它拥有多个独立的齿轮，这些齿轮相互啮合在一起，协同工作，共同...
单相dq解耦控制
qq_38847810的博客
04-26 1万+
1. 单相dq解耦   本周重点剖析单相dq解耦的方式，发现很多论文上关于dq轴的定义都不一样，以及dq变换矩阵的定义都不同，让人感到眼花缭乱，不知道到底哪一个是正确的，经过多篇文献的分析，总结出以下特点。 (1) 确定dq变换矩阵   dq变换矩阵的确定是和dq轴以及αβ\alpha \betaαβ轴的定义有关，也就是说不同的αβ\alpha \betaαβ轴定义或者不同的dq轴定义，最后...
《大话设计模式》C++实现：23 命令模式（三）抽象总结
qq_29567701的博客
10-04 1678
1. UML类图抽象 2. 实例 2.1 结果（结论先行） main.cpp #include "Receiver.h" #include "ICommand.h" #include "ConcreteCmd.h" #include "Invoker.h" void test() { CReceiver* pRcv = new CReceiver(); ICommand* pCmd = new ConcreteCmd(pRcv); Invoker* pInvk = new Invoker();
大话设计模式 c++
09-13
行为型模式包括策略模式、观察者模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式和解释器模式。 每种设计模式都有其特定的应用场景和解决方案，可以根据实际需求选择合适的设计模式来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值