观察者模式-C++

观察者模式（Observer）是一种行为型设计模式，它用于在对象之间建立一对多的依赖关系，当一个对象发生改变时，所有依赖它的对象都会收到通知进行相应的改变。

观察者模式中有两种核心角色：

• 观察者（Observer）：也被称为订阅者或监听者，观察者通过注册到特定的主题上，当主题的状态发生改变时，它可以收到这种变化更新自身状态。观察者定义了一个统一的接口，使得主题可以通过接口将通知发送给所有的观察者。
• 主题（Subject）：也称为被观察者，它管理着一组观察者对象，提供添加、删除观察者对象的方法。当主题发生改变的时候可以将通知发送给所有的观察者对象。

在这里面，观察者依赖主题，所以一个主题可以对应多个观察者。

观察者模式的流程：

• 主题对象管理观察者对象的添加和删除
• 主题对象维护一个观察者对象的列表，用于记录所有注册的观察者对象
• 当主题对象的状态发生改变时，遍历观察者列表，将通知发送给每一个观察者对象
• 观察者对象收到通知后更新自身的状态

观察者模式也有三个组件：观察者接口、观察者、主题

举例：
假设现在我们有一个电子商务平台，当用户下单之后我们希望通知库存系统和用户通知系统。

现在我们按照观察者模式的三个组件来编写代码：观察者接口、观察者、主题：

// 观察者接口
class IObserver
{
public:

	virtual ~IObserver(){}

	virtual void Update(const std::string& _msg) = 0;
};

// 观察者-库存系统
class InventorySystem
	: public IObserver
{
public:

	virtual void Update(const std::string& _msg) override
	{
		std::cout << "库存系统：" << _msg << std::endl;
	}
};

// 观察者-用户通知系统
class UserNotifySystem
	: public IObserver
{
public:

	virtual void Update(const std::string& _msg) override
	{
		std::cout << "用户通知系统：" << _msg << std::endl;
	}
};

// 主题
class Subject
{
public:

	// 添加观察者对象
	void AddObserver(std::shared_ptr<IObserver> _observer)
	{
		if (_observer)
			observers_.push_back(_observer);
	}

	// 删除观察者对象
	void RemoveObserver(std::shared_ptr<IObserver> _observer)
	{
		for (auto it = observers_.begin(); it != observers_.end();)
		{
			if (*it == _observer)
				it = observers_.erase(it);
			else
				it++;
		}
	}

	// 用户下单
	void UserPlatform(const std::string& _msg)
	{
		std::cout << "用户下单：" << _msg << std::endl;

		NotifyAllObserver(_msg);
	}

private:

	// 通知所有的观察者对象
	void NotifyAllObserver(const std::string _msg)
	{
		for (auto it : observers_)
			it->Update(_msg);
	}

private:

	// 记录所有注册的观察者对象
	std::list<std::shared_ptr<IObserver>> observers_;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

在main.cpp里使用它：

void TestObserver()
{
	// 主题对象
	std::shared_ptr<Subject> subject = std::make_shared<Subject>();

	// 观察者对象-库存系统
	std::shared_ptr<IObserver> inventory_system = std::make_shared<InventorySystem>();

	// 观察者对象-用户通知系统
	std::shared_ptr<IObserver> user_notify = std::make_shared<UserNotifySystem>();

	// 注册观察者
	subject->AddObserver(inventory_system);
	subject->AddObserver(user_notify);

	// 用户下单
	subject->UserPlatform("iphone 11");

	std::cout << "---------------------删除 用户通知系统------------------" << std::endl;

	// 删除观察者
	subject->RemoveObserver(user_notify);

	// 用户下单
	subject->UserPlatform("小米 11");
}

int main()
{
    // 策略模式用法
	// TestStrategy();

	TestObserver();

    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

输出：
优点：

• 松耦合：主题和观察者之间是松耦合的，修改一个观察者对象不影响其他对象
• 可扩展：可以在任何时候添加和删除观察者，无需修改已有代码
• 即时通知：一旦主题发生改变，观察者可以立即收到通知。

适用场景：

• 当一个对象发生改变时，希望主动通知其他对象而不是其他对象等待通知时
• 当具有一对多的关系时，一个对象的更新会影响到其他对象时