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

图片引用于百度

简介：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

优点：建立一套触发机制，解除了主题和被观察者之间的耦合关系

缺点：如果观察者中包含了很多的被观察者，逐个通知会花费一些时间。观察者和被观察者有循环依赖的话，会造成死循环。观察者模式不会告诉被观察者是怎么发生变化的，被观察者仅仅知道发生了变化

例子背景：某游戏有个8人对战房间，当某人被淘汰时需要通知到其他玩家

观察者模式代码：

• 被观察者抽象类：

#pragma once
#include <string>
#include <iostream>
#include <list>
using namespace std;

class Watcher
{
public:
        Watcher() = default;
        virtual ~Watcher() = default;
        virtual void Update(const string& pl) = 0;
        virtual string GetName() = 0;
};

• 被观察者具体类：

#pragma once
#include "Watcher.h"

class Player : public Watcher
{
public:
        Player(const string& n) : m_playerName(n) {}
        virtual void Update(const string& pl)
        {
                cout << "玩家" << pl << "被淘汰了" << endl;
        }
        virtual string GetName()
        {
                return m_playerName;
        }
private:
        string m_playerName;
};

• 观察者抽象类：

#pragma once
#include "Watcher.h"

class Watched
{
public:
        Watched() = default;
        virtual ~Watched() = default;
        virtual void AddWatcher(Watcher* watcher) = 0;
        virtual void RemoveWatcher(Watcher* watcher) = 0;
        virtual void NotifyWatchers() = 0;
};

• 观察者具体类：

#pragma once
#include "Watched.h"

class Transporter : public Watched
{
public:
        Transporter() {}
        virtual void AddWatcher(Watcher* watcher)
        {
                m_lstWatcher.push_back(watcher);
        }
        virtual void RemoveWatcher(Watcher* watcher)
        {
                m_lstWatcher.remove(watcher);
        }
        virtual void NotifyWatchers()
        {
                auto n = m_lstWatcher.back();
                m_lstWatcher.pop_back();
                for (auto iter : m_lstWatcher)
                {
                        iter->Update(n->GetName());
                }
        }
private:
        list<Watcher*> m_lstWatcher;
};

• 引用：

#include "Transporter.h"
#include "ConcreteObserver.h"

//模拟多人玩家对战 血掉没了就淘汰一个 通知到其他玩家客户端 告诉他们这个人淘汰了
int main()
{
        shared_ptr<Transporter> transporter(new Transporter);
        shared_ptr<Player> p1(new Player("玩家1"));
        shared_ptr<Player> p2(new Player("玩家2"));
        shared_ptr<Player> p3(new Player("玩家3"));
        shared_ptr<Player> p4(new Player("玩家4"));
        transporter->AddWatcher(p1.get());
        transporter->AddWatcher(p2.get());
        transporter->AddWatcher(p3.get());
        transporter->AddWatcher(p4.get());
        transporter->NotifyWatchers();

        getchar();
        return 0;
}

总结：
观察者模式(Observer)：降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系，建立起了一套触发机制

作者：丶梦爱
博客：https://blog.csdn.net/u014732297（转载请说明出处）