C++ 设计模式-观察者模式

最新推荐文章于 2024-05-15 08:39:49 发布
最新推荐文章于 2024-05-15 08:39:49 发布
阅读量648 收藏
点赞数
分类专栏： 设计模式 C++语法 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangdamingll/article/details/120770146
版权

设计模式介绍

一、观察者模式

1. 观察者模式定义

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

2. 观察者模式本质

观察者模式的本质:触发联动

3. 观察者模式结构和说明

(1) 结构

在这里插入图片描述
在这里插入图片描述

(2) 调用顺序

在这里插入图片描述
在这里插入图片描述

4. 观察者模式适用情况

  • 当一个抽象模型有两个方面，其中一个方面的操作依赖于另一个方面的状态变化，那么就可以选用观察者模式，将这两者封装成观察者和目标对象，当目标对象变化的时候，依赖于它的观察者对象也会发生相应的变化。这样就把抽象模型的这两个方面分离开了，使得它们可以独立地改变和复用。
  • 如果在更改一个对象的时候，需要同时连带改变其他的对象，而且不知道究竟应该有多少对象需要被连带改变，这种情况可以选用观察者模式，被更改的那一个对象很明显就相当于是目标对象，而需要连带修改的多个其他对象，就作为多个观察者对象了。
  • 当一个对象必须通知其他的对象，但是你又希望这个对象和其他被它通知的对象是松散耦合的。也就是说这个对象其实不想知道具体被通知的对象。这种情况可以选用观察者模式，这个对象就相当于是目标对象，而被它通知的对象就是观察者对象了。

5. 观察者模式优缺点

(1) 优点
  • 观察者模式实现了观察者和目标之间的抽象耦合
    原本目标对象在状态发生改变的时候，需要直接调用所有的观察者对象，但是抽象出观察者接口以后，目标和观察者就只是在抽象层面上耦合了，也就是说目标只是知道观察者接口，并不知道具体的观察者的类，从而实现目标类和具体的观察者类之间解耦。
  • 观察者模式实现了动态联动
    所谓联动，就是做一个操作会引起其他相关的操作。由于观察者模式对观察者注册实行管理，那就可以在运行期间，通过动态地控制注册的观察者，来控制某个动作的联动范围，从而实现动态联动。
  • 观察者模式支持广播通信
    由于目标发送通知给观察者是面向所有注册的观察者，所以每次目标通知的信息就要对所有注册的观察者进行广播。当然，也可以通过在目标上添加新的功能来限制广播的范围。
    在广播通信的时候要注意一个问题，就是相互广播造成死循环的问题。比如A和B两个对象互为观察者和目标对象，A对象发生状态变化，然后A来广播信息，B对象接收到通知后，在处理过程中，使得B对象的状态也发生了改变，然后B来广播信息，然后A对象接到通知后，又触发广播信息…,如此A引起B变化，B又引起A变化，从而一直相互广播信息，就造成死循环。
(2) 缺点
  • 可能会引起无谓的操作
    由于观察者模式每次都是广播通信，不管观察者需不需要，每个观察者都会被调用update方法，如果观察者不需要执行相应处理，那么这次操作就浪费了。其实浪费了还好，最怕引起误更新，那就麻烦了，比如，本应该在执行这次状态更新前把某个观察者删除掉，这样通知的时候就没有这个观察者了，但是现在忘掉了，那么就会引起误操作。

6. 相关模式

  • 观察者模式和状态模式
    观察者模式和状态模式是有相似之处的。
    观察者模式是当目标状态发生改变时，触发并通知观察者，让观察者去执行相应的操作。而状态模式是根据不同的状态，选择不同的实现，这个实现类的主要功能就是针对状态相应地操作，它不像观察者，观察者本身还有很多其他的功能，接收通知并执行相应处理只是观察者的部分功能。
    当然观察者模式和状态模式是可以结合使用的。观察者模式的重心在触发联动，但是到底决定哪些观察者会被联动，这时就可以采用状态模式来实现了，也可以采用策略模式来进行选择需要联动的观察者。
  • 观察者模式和中介者模式
    观察者模式和中介者模式是可以结合使用的。前面的例子中目标都只是简单地通知一下，然后让各个观察者自己去完成更新就结束了。如果观察者和被观察的目标之间的交互关系很复杂，比如，有一个
    界面，里面有三个下拉列表组件，分别是选择国家、省份州、具体的城市，很明显这是一个三级联动，当你选择一个国家的时候，省份/州应该相应改变数据，省份/州一改变，具体的城市也需要改变。这种情况下，很明显需要相关的状态都联动准备好了，然后再一次性地通知观察者。也就是界面做更新处理，不会仅国家改变一下，省份和城市还没有改，就通知界面更新。这种情况就可以使用中介者模式来封装观察者和目标的关系

二、观察者模式示例代码

#include <iostream>
#include <string>
#include <list>

using namespace std;

//观察者模式拉模型实现

class BlogBase;

//观察者
class ObserverBase
{
public:
    ObserverBase() = default;
    virtual ~ObserverBase() = default;
    virtual void Update(const BlogBase& blog) = 0;
};

//博客
class BlogBase
{
public:
    BlogBase() = default;
    virtual ~BlogBase()  = default;
    void Attach(ObserverBase *observer) { m_observers.push_back(observer); }	 //添加观察者
    void Remove(ObserverBase *observer) { m_observers.remove(observer); }        //移除观察者
    void Notify(const BlogBase& blog) //通知观察者
    {
        auto iter = m_observers.begin();
        for(; iter != m_observers.end(); iter++)
            (*iter)->Update(blog);
    }

    virtual void SetStatus(string s) = 0; //设置状态
    virtual string GetStatus() const= 0;    //获得状态
private:
    list<ObserverBase* > m_observers; //观察者链表
};

//具体博客类
class BlogCSDN : public BlogBase
{
private:
    string m_name; //博主名称
public:
    explicit BlogCSDN(string name): m_name(std::move(name)) {}
    ~BlogCSDN() override  = default;

    void SetStatus(string s) override {  //具体设置状态信息
        m_status = "CSDN:" + m_name + ":" + s;
        Notify(*this);
    }
    string GetStatus() const override { return m_status; }

protected:
    string m_status; //状态
};

//具体观察者
class ObserverBlogCSDN : public ObserverBase
{
private:
    string m_name;  //观察者名称
public:
    ObserverBlogCSDN(string name): m_name(std::move(name)){}
    ~ObserverBlogCSDN() override  = default;
    void Update(const BlogBase& blog) override
    {
        cout<<m_name<<" observer->"<<blog.GetStatus()<<endl;  //拉模型
    }
};

int main(){
    BlogBase *blog = new BlogCSDN("wangdaming");
    ObserverBase *observer1 = new ObserverBlogCSDN("wangdaming");
    blog->Attach(observer1);
    blog->SetStatus("DesignMode");
    blog->SetStatus("DataStruct");
    blog->Remove(observer1);
    delete blog;
    delete observer1;
    return 0;
}

#include <iostream>
#include <string>
#include <list>

using namespace std;

//观察者模式推模型实现

class BlogBase;

//观察者
class ObserverBase
{
public:
    ObserverBase() = default;
    virtual ~ObserverBase() = default;
    virtual void Update(const std::string& status) = 0;
};

//博客
class BlogBase
{
public:
    BlogBase() = default;
    virtual ~BlogBase()  = default;
    void Attach(ObserverBase *observer) { m_observers.push_back(observer); }	 //添加观察者
    void Remove(ObserverBase *observer) { m_observers.remove(observer); }        //移除观察者
    void Notify(const std::string& status) //通知观察者
    {
        auto iter = m_observers.begin();
        for(; iter != m_observers.end(); iter++)
            (*iter)->Update(status);
    }

    virtual void SetStatus(string s) = 0; //设置状态
    virtual string GetStatus() const= 0;    //获得状态
private:
    list<ObserverBase* > m_observers; //观察者链表
};

//具体博客类
class BlogCSDN : public BlogBase
{
private:
    string m_name; //博主名称
public:
    explicit BlogCSDN(string name): m_name(std::move(name)) {}
    ~BlogCSDN() override  = default;

    void SetStatus(string s) override {  //具体设置状态信息
        m_status = "CSDN:" + m_name + ":" + s;
        Notify(m_status);
    }
    string GetStatus() const override { return m_status; }

protected:
    string m_status; //状态
};

//具体观察者
class ObserverBlogCSDN : public ObserverBase
{
private:
    string m_name;  //观察者名称
public:
    ObserverBlogCSDN(string name): m_name(std::move(name)){}
    ~ObserverBlogCSDN() override  = default;
    void Update(const std::string& status) override
    {
        cout<<m_name<<" observer->"<<status<<endl;  //推模型
    }
};

int main(){
    BlogBase *blog = new BlogCSDN("wangdaming");
    ObserverBase *observer1 = new ObserverBlogCSDN("wangdaming");
    blog->Attach(observer1);
    blog->SetStatus("DesignMode");
    blog->SetStatus("DataStruct");
    blog->Remove(observer1);
    delete blog;
    delete observer1;
    return 0;
}

#include <iostream>
#include <string>
#include <list>

using namespace std;

//动态触发联动:区别对待观察者

class BlogBase;

//观察者
class ObserverBase
{
public:
    ObserverBase() = default;
    virtual ~ObserverBase() = default;
    virtual void Update(const BlogBase& blog) = 0;
    virtual std::string GetName() = 0;
};

//博客
class BlogBase
{
public:
    BlogBase() = default;
    virtual ~BlogBase()  = default;
    void Attach(ObserverBase *observer) { m_observers.push_back(observer); }	 //添加观察者
    void Remove(ObserverBase *observer) { m_observers.remove(observer); }        //移除观察者

    virtual void SetStatus(string s) = 0; //设置状态
    virtual string GetStatus() const= 0;    //获得状态

    virtual void SetOp(string op) = 0; //设置操作
    virtual string GetOp() const= 0;    //获得操作

protected:
    virtual void Notify(const BlogBase& blog) //通知观察者
    {
        auto iter = m_observers.begin();
        for(; iter != m_observers.end(); iter++)
        {
            (*iter)->Update(blog);
        }
    }

protected:
    list<ObserverBase* > m_observers; //观察者链表
};

//具体博客类
class BlogCSDN : public BlogBase
{
private:
    string m_name; //博主名称
public:
    explicit BlogCSDN(string name): m_name(std::move(name)) {}
    ~BlogCSDN() override  = default;

    void SetStatus(string s) override {  //具体设置状态信息
        m_status = "CSDN:" + m_name + ":" + s;
        Notify(*this);
    }
    string GetStatus() const override { return m_status; }

    void SetOp(string op) override {  //具体设置状态信息
        m_op = op;
    }
    string GetOp() const override { return m_op; }

protected:
    void Notify(const BlogBase& blog) override //通知观察者
    {
        auto iter = m_observers.begin();
        for(; iter != m_observers.end(); iter++)
        {
            std::string op = GetOp();
            if(op == "modify" && (*iter)->GetName() == "wangdaming")
            {
                (*iter)->Update(blog);
            }

            if(op == "update" && (*iter)->GetName() == "others")
            {
                (*iter)->Update(blog);
            }
        }
    }
protected:
    string m_status ; //状态
    string m_op ;//操作
};

//具体观察者
class ObserverBlogCSDN : public ObserverBase
{
public:
    ObserverBlogCSDN(string name): m_name(std::move(name)){}
    ~ObserverBlogCSDN() override  = default;
    void Update(const BlogBase& blog) override
    {
        cout<<m_name<<" observer->"<<blog.GetStatus()<<":"<<blog.GetOp()<<endl;  //拉模型
    }
    std::string GetName() override
    {
        return m_name;
    }

private:
    string m_name;  //观察者名称
};

int main(){
    BlogBase *blog = new BlogCSDN("wangdaming");
    ObserverBase *observer1 = new ObserverBlogCSDN("wangdaming");
    ObserverBase *observer2 = new ObserverBlogCSDN("others");
    blog->Attach(observer1);
    blog->Attach(observer2);

    blog->SetOp("modify");
    blog->SetStatus("DesignMode");

    blog->SetOp("update");
    blog->SetStatus("DataStruct");

    blog->Remove(observer1);
    blog->Remove(observer2);
    delete blog;
    delete observer1;
    return 0;
}


#include <iostream>
#include <string>
#include <list>
#include <memory>

using namespace std;

//观察者模式拉模型实现
//采用weak_ptr方式实现观察者列表
//优点:观察者目标类能知道观察者列表中的对象是否有效

class BlogBase;

//观察者
class ObserverBase
{
public:
    ObserverBase() = default;
    virtual ~ObserverBase() = default;
    virtual void Update(const BlogBase& blog) = 0;
};

//博客
class BlogBase
{
public:
    BlogBase() = default;
    virtual ~BlogBase()  = default;
    void Attach(std::weak_ptr<ObserverBase>&& observer)  //添加观察者
    {
        m_observers.push_back(std::move(observer));
    }
    void Remove(const std::weak_ptr<ObserverBase>& observer) //移除观察者
    {
        m_observers.remove_if([&](const std::weak_ptr<ObserverBase>& item)->bool{
            if(!item.expired())
            {
                return item.lock() == observer.lock();
            }
            return false;
        });
    }
    void Notify(const BlogBase& blog) //通知观察者
    {
        auto iter = m_observers.begin();
        for(; iter != m_observers.end();)
        {
            if(!iter->expired())
            {
                iter->lock()->Update(blog);
                iter++;
            } else{
                std::cout<<"observer is null."<<std::endl;
                iter = m_observers.erase(iter);
            }
        }
    }

    uint32_t Size(){return m_observers.size();}

    virtual void SetStatus(string s) = 0; //设置状态
    virtual string GetStatus() const= 0;    //获得状态
private:
    list<std::weak_ptr<ObserverBase>> m_observers; //观察者链表
};

//具体博客类
class BlogCSDN : public BlogBase
{
private:
    string m_name; //博主名称
public:
    explicit BlogCSDN(string name): m_name(std::move(name)) {}
    ~BlogCSDN() override  = default;

    void SetStatus(string s) override {  //具体设置状态信息
        m_status = "CSDN:" + m_name + ":" + s;
        Notify(*this);
    }
    string GetStatus() const override { return m_status; }

protected:
    string m_status; //状态
};

//具体观察者
class ObserverBlogCSDN : public ObserverBase
{
private:
    string m_name;  //观察者名称
public:
    ObserverBlogCSDN(string name): m_name(std::move(name)){}
    ~ObserverBlogCSDN() override  = default;
    void Update(const BlogBase& blog) override
    {
        cout<<m_name<<" observer->"<<blog.GetStatus()<<endl;  //拉模型
    }
};

int main(){
    BlogBase *blog = new BlogCSDN("wangdaming");
    std::shared_ptr<ObserverBase> pShare1 = std::make_shared<ObserverBlogCSDN>("wangdaming");
    blog->Attach(pShare1);
    {
        std::shared_ptr<ObserverBase> pShare2 = std::make_shared<ObserverBlogCSDN>("others");
        blog->Attach(pShare2);
        blog->SetStatus("DesignMode");
    }
    blog->SetStatus("DataStruct");
    blog->Remove(pShare1);
    delete blog;
    return 0;
}
A鱼翔浅底A
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式 - 观察者Observer模式
大秦坑王的专栏
03-25 3755
C++面向对象设计模式之观察者模式
C++设计模式——观察者模式(Observer Pattern)
leonardohaig的博客
09-15 6931
C++设计模式——观察者模式(Observer Pattern) 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——观察者模式(Observer Pattern)目录前言定义代码示例总结观察者模式和中介模式优缺点适用场景及应用示例参考资料 前言 观察者模式面向的需求是：A对象（观察者）对B对象（被观察者）的某种变化高度敏感，需要在B变化的一瞬间做出反应。举个例子，新闻里喜闻乐见的警察抓小偷，警察需要在小偷伸手作案的时候实施抓捕。在这个例子里，警察是观察者、小偷是被观察者，警察需要时刻盯着小偷的一
C C++最新（三）行为模式：7、观察者模式（Observer Pattern，2024年最新C C++高频面试题+解析
最新发布
2401_84976170的博客
05-15 318
观察者模式（Observer Pattern）是一种行为型设计模式，它定义了对象之间的一对多依赖关系，使得当一个对象状态发生改变时，所有依赖它的对象都会自动收到通知并更新。（2）当一个抽象模型有两个方面，其中一个方面依赖于另一个方面，将这两个方面封装在独立的对象中，使它们可以独立地改变和复用时。：具体的观察者对象，继承或实现了Observer接口，可以有多个不同的具体观察者。：被观察的对象，它维护了一个观察者列表，并提供了添加、删除和通知观察者的方法。1）观察者过多时，会导致通知时间增加，影响性能。
C++设计模式——观察者模式
Map的博客
04-10 2173
1.观察者模式 定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动刷新。 观察者模式又叫做发布-订阅(Publish-Subscribe)模式、模型-视图(Model-View)模式、源-监听器(Source-Listener)模式。 2. 场景举例 角色： 抽象主题（Subject）：该角色是一个抽象类或接口，定义了增加、删除、通知观...
观察者模式（C++实现）
qq_23903863的博客
08-14 1046
（本博客旨在个人总结回顾） 1、详情： 观察者模式：定义对象间一种一对多的依赖关系，以便当该对象状态发生改变时，所有依赖它的对象都得到通知并自动刷新。 说明： 优点： ①观察者和被观察者是抽象耦合的。 ②建立一套触发机制。 缺点： ①如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 ②如果在观察者和观察目标之间有循环依赖的话，观察目标会触...
c++之观察者模式
燃犀的博客
07-14 2357
c++之观察者模式
3.观察者模式C++用法示例
lzq8090的博客
04-06 600
观察者模式（Observer Pattern）是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听一个主题对象，当主题对象状态发生改变时，会通知所有观察者对象，使它们自动更新自己。
c++设计模式-行为型模式-观察者模式
06-21
c++设计模式-行为型模式-观察者模式；qt工程；c++简单源码； 观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式...
C++设计模式--观察者模式 demo
04-14
在"C++设计模式--观察者模式 demo"中，我们可能看到如下关键部分： - **定义观察者接口**：通常会有一个名为`Observer`的抽象类，包含`update`方法。 ```cpp class Observer { public: virtual void update() = 0;...
C++设计模式之观察者模式
01-21
这就要说到今天总结的观察者模式了，作为设计模式大家庭中最重要的一个，我们不得不去好好的学习一下观察者模式。 观察者模式 在GOF的《设计模式:可复用面向对象软件的基础》一书中对观察者模式是这样说的：定义对象...
C++设计模式--基于Qt4开源跨平台开发框架
01-06
《C++设计模式--基于Qt4开源跨平台开发框架》一书主要探讨了如何在C++编程中利用设计模式，并结合Qt4框架进行高效的跨平台应用开发。设计模式是软件工程中的重要概念，它们是经过时间和实践验证的解决特定问题的模板...
观察者模式的实现
12-08
观察者模式的实现，使用list实现，C++编程思想还是设计模式都有介绍的，很好的
c++观察者模式实例
11-05
c++中应用的观察着模式，软件环境是cocos2d-x，因为个人觉得还是很详细的思维值得借鉴。只是代码，没有readme文档导读
设计模式-观察者模式-作业-observer.zip
08-27
观察者模式（Observer Pattern）是软件设计模式中的行为模式之一，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动或发布-...
C++设计模式-观察者模式详解
wb175208的专栏
12-21 2804
观察者模式：定义了对象一对多之间的依赖关系，使得对象发生变化的时候，则所有依赖它的所有对象都会得到通知并且得到更新。 一、在古代的时候，政府发布消息或者要找罪犯的时候，一般都会在城门的位置张贴一张布告，但是认字的老百姓又不多，于是就由念过书秀才读给大家听。 场景已经知道了，那么咱们就通过程序来实现。 首先定义一个通知类和秀才类，通知类用来发布通知，秀才类作为通知类的一个成员变量（采用委托的方式）用...
C++实现观察者(Observer)模式
weixin_30955617的博客
04-24 119
观察者(Observer)模式，是常见的模式之一。比如一份报纸，有很多订户。订阅者并不知道报纸何时会送来，他只知道自己订了这份报纸。订阅者在这里担任着观察者的角色，而报社则是被观察者。 报纸一旦印刷完毕，就应该及时送到订户手中，如果将报社看作一个对象，则报纸便是观察者（订户）和被观察者（报社）之间的纽带。观察者需要维护一个与报纸相关的变量或函数，在这个具体问题中，这个变量就是订户...
c++设计模式之-观察者模式
m0_46929878的博客
08-27 54
我们可以看到抽象的被观察者类中有三个public的成员函数，这个类图画的不大对，应该还要有一个list<Observer*>的数据成员，用来保存观察者；只有一个public的update函数，可以加一个被观察者类的指针作为数据成员，当被观察者发生改变时，会调用update更新自己观察到的状态。这三个成员函数从函数名字就知道其作用，添加观察者，删除观察者，通知观察者。3）具体的被观察者，继承了抽象的被观察者类，作为子类实现父类的纯虚函数。4）具体的观察者，继承了抽象的观察者类。1）目标类(被观察者）
C++设计模式<五>：Observe观察者模式
耗纸的博客
04-09 1628
1.动机在软件构建过程中，我们需要为某些对象建立一种“通知依赖关系”——一个对象(目标对象)的状态发生改变，所有的依赖对象(观察者对象)都将得到通知。如果这样的依赖关系过于紧密，将使软件不能很好滴抵御变化2.模式定义定义对象间的一种一对多(变化)的依赖关系，以便当一个对象(object)的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。3.例子看一个文件分割器的例子(以前磁盘小，经常需要文件
C++观察者模式
萧海的博客
10-28 161
头文件： #ifndef COBSERVERMODE_H #define COBSERVERMODE_H #include<QDebug> #include <iostream> #include<string> #include <vector> using namespace std; #define cout qDebug() << "[" << __FILE__ << ":" << __LINE__
C语言实现观察者模式
10-09
C语言实现观察者模式需要以下步骤： 1. 定义一个观察者接口（Observer），包含一个更新方法（update），用于接收被观察者（Subject）的通知。 2. 定义一个被观察者接口（Subject），包含添加观察者、删除观察者、通知观察者等方法。 3. 实现观察者接口，创建具体的观察者类。 4. 实现被观察者接口，创建具体的被观察者类，并在其中维护一个观察者列表。 5. 当被观察者发生变化时，调用通知方法，将变化传递给所有观察者。 以下是C语言实现观察者模式的示例代码： ``` #include <stdio.h> #include <stdlib.h> typedef struct Observer Observer; typedef struct Subject Subject; // 观察者接口 struct Observer { void (*update)(Observer *); }; // 被观察者接口 struct Subject { void (*attach)(Subject *, Observer *); void (*detach)(Subject *, Observer *); void (*notify)(Subject *); }; // 具体观察者 struct ConcreteObserver { Observer base; int state; }; void ConcreteObserver_update(Observer *observer) { ConcreteObserver *self = (ConcreteObserver *)observer; printf("Observer state update: %d\n", self->state); } ConcreteObserver *ConcreteObserver_create(int state) { ConcreteObserver *self = malloc(sizeof(ConcreteObserver)); self->base.update = ConcreteObserver_update; self->state = state; return self; } // 具体被观察者 struct ConcreteSubject { Subject base; Observer **observers; int count; }; void ConcreteSubject_attach(Subject *subject, Observer *observer) { ConcreteSubject *self = (ConcreteSubject *)subject; self->count++; self->observers = realloc(self->observers, sizeof(Observer *) * self->count); self->observers[self->count - 1] = observer; } void ConcreteSubject_detach(Subject *subject, Observer *observer) { ConcreteSubject *self = (ConcreteSubject *)subject; for (int i = 0; i < self->count; i++) { if (self->observers[i] == observer) { for (int j = i; j < self->count - 1; j++) { self->observers[j] = self->observers[j + 1]; } self->count--; self->observers = realloc(self->observers, sizeof(Observer *) * self->count); break; } } } void ConcreteSubject_notify(Subject *subject) { ConcreteSubject *self = (ConcreteSubject *)subject; for (int i = 0; i < self->count; i++) { self->observers[i]->update(self->observers[i]); } } ConcreteSubject *ConcreteSubject_create() { ConcreteSubject *self = malloc(sizeof(ConcreteSubject)); self->base.attach = ConcreteSubject_attach; self->base.detach = ConcreteSubject_detach; self->base.notify = ConcreteSubject_notify; self->observers = NULL; self->count = 0; return self; } int main() { ConcreteSubject *subject = ConcreteSubject_create(); ConcreteObserver *observer1 = ConcreteObserver_create(1); ConcreteObserver *observer2 = ConcreteObserver_create(2); subject->base.attach(&subject->base, &observer1->base); subject->base.attach(&subject->base, &observer2->base); subject->base.notify(&subject->base); subject->base.detach(&subject->base, &observer2->base); subject->base.notify(&subject->base); free(observer1); free(observer2); free(subject->observers); free(subject); return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值