C++ 设计模式（可复用面向对象软件的基础）学习笔记——第五讲 观察者模式

 

对于设计模式初学者来说，GoF的这本设计模式（可复用面向对象软件的基础）是有些难理解的，因此我先看了视频教程，附上教程链接网址https://www.bilibili.com/video/av52251106/?p=5。

       以下是我的学习笔记整理，分享给有需要的朋友，记录的比较简单，如有不理解的地方可以看原教程视频链接，或者留言给我，本小菜和你一起探讨。

一、“组件协作”模式

1.现代 软件专业分工之后的第一个结果是“框架与应用程序的划分”，“组件协作”模式通过晚期绑定，来实现框架与应用程序之间的松耦合，是二者之间协作时常用的模式。

2.典型模式

    Template Method

    Strategy

    Observer/Event                    

二、动机（Motivation）

1.在软件构建过程中，我们需要为某些对象建立一种“通知依赖关系”——一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知。如果这样的依赖关系过于紧密，将使软件不能很好的抵御变化。

2.使用面向对象技术，可以将这种依赖关系弱化，并形成一种稳定的依赖关系。从而实现软件体系结构的松耦合。

三、代码实例

FileSplitter.cpp:

class Iprogress{

public:

        virtual void DoProgress(float value) = 0;

        virtual ~IProgress(){}

};

 

class FileSplitter

{

        string m_filePath;

        int m_fileNumber;

 

       list<ProgressBar*> m_iprogressList;//抽象通知机制

public:

        FIleSplitter(const string& filePath,int fileNumber):

                m_filePath(filePath),

                m_fileNumber(fileNumber){

        }

 

        void addIProgress(Iprogress*){

                m_iprogressList.add(Iprogress);

        }

 

        void removeIProgress(Iprogress*){

                m_iprogressList.remove(Iprogress);

        }

 

        void split(){

                //1.读取大文件

                

                //2.分批次向小文件中写入

                for(int i = 0; i < m_fileNumber; i++){

                        //...

                        float progressValue = m_fileNumber;

                        progressValue = (i+1)/progressValue;

                        OnProgress(progressValue);

                }

        }

protected:

        virtual void OnProgress(float value){

                List<IProgress*>::Iterator itor = m_iprogressList.begin();

                while(itor != m_iprogressList.end()){

                        (*itor)->DoProgress(value);//更新进度

                        itor++;

                }

        }

};

 

MainForm.cpp:

注意：c++不推荐多继承，除非一个父类是主流程，其他都是接口类。

class MainForm : public Form, public Iprogress

{

        TextBox* txtFilePath;

        TextBox* txtFileNumber;

 

        ProgressBar* progressBar;

public:

        void Button1_Click(){

                string filePath = txtFilePath->getText();

                int number = atoi(txtfileNumber->getText().c_str());

            

                ConsoleNotifier cn;

 

                FileSplitter splitter(filePath,number);

 

                splitter.addIProgress(this);//订阅通知

                splitter.addIProgress(&cn);//订阅通知

 

                splitter.split();

        }

        

        virtual void DoProgress(float value){

                progressBar->setValue(value);

        }

};

 

class consoleNotifier : public Iprogress{

public:

        virtual void DoProgress(float value){

                cout <<".";

        }

}

 

四、模式定义

 

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

                                            ——《设计模式》GoF

 

五、要点总结

1.使用面向对象的抽象，observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达至松耦合。

2.目标发送通知时，无需指定观察者，通知（可以携带通知信息作为参数）会自动传播。

3.观察者自己决定是否需要订阅通知，目标对象对此一无所知。

4.Observer模式是基于事件的UI框架中非常常用的设计模式，也是MVC模式的一个重要组成部分。

六、最简伪代码

//IDo类是观察者需要执行功能的基类

class IDo{

public:

       virtual dothing()=0;

      virtual ~IDo();

};

//IDo1观察者需要通知执行功能的实现子类1

class IDo1 : public IDo{

public:

       virtual dothing(){

       实现1功能；

       }

};

//IDo2观察者需要通知执行功能的实现子类2

class IDo2 : public IDo{

public:

       virtual dothing(){

       实现2功能；

       }

};

//观察者通知列表类

class NotifyList{

List<IDo*> m_alist;

public:

       void addN(IDo* do){

              m_alist.add(do);

       }

      void removeN(IDo* do){

              m_alist.remove(do);

      }

      void fun(){

             onDo();

      }

protected:

     void onDo(){

            void* itor = m_alist.begin();

            while(itor!= m_alist.end()){

                    (*itor)->dothing();

                    itor++;

          }

     };

//业务通知类，根据具体情况添加需要通知的业务。

//唯一一个后续需要根据业务更改的类

class notify{

        NotifyList m_nl;

public:

         void event1(){

               IDo1 do1;

               m_nl.addN(do1);

               IDo2 do2;

                m_nl.addN(do2);

         }

         void funN(){

                 m_nl.fun();

          }

}