C++常用23种设计模式总结(二)------观察者模式

往期回顾
C++常用23种设计模式总结(一)------单例模式

什么是观察者模式

观察者模式是一种设计模式，它允许对象之间建立一对多的依赖关系，当一个对象状态发生改变时，它的所有依赖者都会收到通知并自动更新。

在C++中，观察者模式可以通过以下步骤实现：

创建一个抽象主题类（Subject），该类定义了主题（被观察者）必须实现的方法，包括添加和删除观察者以及通知观察者的方法。
创建一个抽象观察者类（Observer），该类定义了观察者必须实现的方法，包括更新方法。
创建具体主题类（ConcreteSubject），该类继承了抽象主题类，并实现了具体的方法。在状态发生改变时，具体主题类会通知观察者。
创建具体观察者类（ConcreteObserver），该类继承了抽象观察者类，并实现了具体的更新方法。具体观察者类可以通过具体主题类注册为观察者，从而接收状态更新通知。
使用观察者模式，可以实现松耦合的系统，使得各个对象之间相互独立。同时也提供了更好的可扩展性和灵活性，因为可以动态地添加或删除观察者对象，而不需要修改主题代码。

具体实现如下

1、首先创建两个抽象类

class AbstractSubject           //抽象主题
{
public:
        virtual void add(AbstractObserver * obs) = 0;
        virtual void del(AbstractObserver * obs) = 0;
        virtual void notify() = 0;
};


class AbstractObserver          //抽象观察者
{
public:
    virtual void update() = 0;
};

2、重写这两个接口

class Subject : public AbstractSubject //主题具体实现
{
public:
    Subject()
    { 
        std::cout<<" Create Subject"<<std::endl; 
    };
    ~Subject() { };

public:
    void add(AbstractObserver * obs) override
    {
        m_observers.push_back(obs);
    }
    void del(AbstractObserver * obs) override
    {

    }
    void notify() override
    {
        for(auto iter : m_observers)
        {
            iter->update();
        }
    }

    void setValue(std::string value)
    {
        m_val = value;
        notify();
    }
    std::string getValue()
    {
        return m_val;
    }


private:
    std::string m_val;
    std::vector<AbstractObserver *> m_observers;
};



class Observer : public AbstractObserver   //观察者具体实现
{

public:
    Observer(Subject* Subject)
    :m_Subject(Subject)
    {

    }

public:
    void update() override
    {
        std::cout<<"recv : "<<m_Subject->getValue()<<std::endl;
    }

private:
    Subject* m_Subject;
};

完整测试代码

#include 
#include 
#include 

using namespace std;

class AbstractObserver;
class AbstractSubject           //抽象主题
{
public:
        virtual void add(AbstractObserver * obs) = 0;
        virtual void del(AbstractObserver * obs) = 0;
        virtual void notify() = 0;
};


class AbstractObserver          //抽象观察者
{
public:
    virtual void update() = 0;
};


class Subject : public AbstractSubject
{
public:
    Subject()
    { 
        std::cout<<" Create Subject"<<std::endl; 
    };
    ~Subject() { };

public:
    void add(AbstractObserver * obs) override
    {
        m_observers.push_back(obs);
    }
    void del(AbstractObserver * obs) override
    {

    }
    void notify() override
    {
        for(auto iter : m_observers)
        {
            iter->update();
        }
    }

    void setValue(std::string value)
    {
        m_val = value;
        notify();
    }
    std::string getValue()
    {
        return m_val;
    }


private:
    std::string m_val;
    std::vector<AbstractObserver *> m_observers;
};



class Observer : public AbstractObserver
{

public:
    Observer(Subject* Subject)
    :m_Subject(Subject)
    {

    }

public:
    void update() override
    {
        std::cout<<"recv : "<<m_Subject->getValue()<<std::endl;
    }

private:
    Subject* m_Subject;
};

int main()
{
    //创建主题
    Subject * sub = new Subject();
    //创建监控者
    AbstractObserver * obs1 = new Observer(sub);
    AbstractObserver * obs2 = new Observer(sub);

    sub->add(obs1);
    sub->add(obs2);

    sub->setValue("hello");

    delete sub;
    delete obs1;
    delete obs2;

    sub = nullptr;
    obs1 = nullptr;
    obs2 = nullptr;

    return 0;
}

运行结果

 Create Subject
recv : hello
recv : hello