• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            來吧,朋友!

            為C++瘋狂

            Generic Observer Pattern and Events in C++

            Introduction

            One of the interesting features I found in C# is a ?Events and Delegates? concept. The idea is good but not new in Object Oriented Programming, it is one of the most frequently used concepts in programming, sometimes referred to as ?Observer? or ?Document/View? design pattern. Classical formulation of it could be found in ?Design Patterns, Elements of Reusable Object Oriented Software? by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides (The Gang of Four).

            This concept is used when you want some information stored in one object, called ?model? (subject) to be watched by others, called ?views? (observers). Each time when information is changed in the ?model?, ?views? attached to the model should receive notification and update there states accordingly to the changed ?model?.

            Classical implementation described in ?Design Patterns?:

            As it is seen from the class diagram, concrete models should be derived from Subject class and views from Observer. Any time the state of Subject is changed, it calls notify method which notifies all observers attached to the Subject.

            Collapse Copy Code
            void Subject::notify()
            {
            for(int i=0; i<observes.size(); i++)
            observers[i]->update();
            }

            In many applications, this straightforward implementation is good enough, but things are getting ugly when you have different kinds of changes in the ?subject? and you want to pass different types of parameters to the ?views?.

            One of the examples for complex ?Model?/?View? relations is a GUI control attached to its processing function. Each time the control?s state is changed, process function is called with parameters indicating new state of the control.

            These kinds of problems are solved in C# by the introduction of ?Events and Delegates? concept. The resolution of the problem is easier in C#, because all classes are inherited from the same ?object? class.

            At the beginning, I thought why we do not have this nice ?Events and Delegates? thing in standard C++, but then I came to the conclusion that C++ does not need it.

            C++ language is powerful enough to express ?Events? and ?Delegates? concept in terms of already existing primitives. Proposed design makes it possible to "connect" different methods with different number of parameters belonging to unrelated classes to the ?model?.

            The keys for this solution are C++ templates (generic types) and pointes to member functions.

            Using Code

            Suppose we have a class MySubject that has internal information connected to different views, it produces three different types of events called int_event, double_event and triple_event with different types and numbers of parameters.

            Collapse Copy Code
            class MySubject
            {
            public:
            CppEvent1<bool,int> int_event;
            CppEvent2<bool,double,int> double_event;
            CppEvent3<bool,double,int,const char*> triple_event;
            void submit_int()
            {
            int_event.notify(1);
            }
            void submit_double()
            {
            double_event.notify(10.5,100);
            }
            void submit_triple()
            {
            triple_event.notify(10.5,100,"Oh ye");
            }
            };

            Views represented by MyListener1 and MyListener2 are unrelated. The only requirement is for callback (delegate) methods to have parameters signature similar to corresponding CppEvent.

            Collapse Copy Code
            class MyListener1
            {
            public:
            bool update_int(int p)
            {
            Console::WriteLine(S"int update listener 1");
            return true;
            }
            bool update_double(double p,int p1)
            {
            Console::WriteLine(S"double update listener 1");
            return true;
            }
            bool update_triple(double p,int p1,const char* str)
            {
            Console::WriteLine(S"triple update listener 1");
            return true;
            }
            };
            class MyListener2
            {
            public:
            bool fun(int p)
            {
            Console::WriteLine(S"int update listener 2");
            return true;
            }
            };

            The final step is to create viewers MyListener1 and MyListener2 and connect their member functions to corresponding events in MySubject model.

            Collapse Copy Code
            int main(void)
            {
            // create listeners (viewers)
                MyListener1* listener1 = new MyListener1;
            MyListener2* listener2 = new MyListener2;
            // create model
                MySubject subject;
            // connect different viewers to different events of the model
                CppEventHandler h1 = subject.int_event.attach(listener1,
            &MyListener1::update_int);
            CppEventHandler h2 = subject.int_event.attach(listener2,
            &MyListener2::fun);
            CppEventHandler h3 = subject.double_event.attach(listener1,
            &MyListener1::update_double);
            CppEventHandler h4 = subject.triple_event.attach(listener1,
            &MyListener1::update_triple);
            // generate events
                subject.submit_int();
            subject.submit_double();
            subject.submit_triple();
            // detach handlers
                subject.int_event.detach(h1);
            subject.int_event.detach(h2);
            subject.double_event.detach(h3);
            subject.triple_event.detach(h4);
            return 0;
            }

            Resulting output is:

            Collapse Copy Code
            > int update listener 1
            > int update listener 2
            > double update listener 1
            > triple update listener 1

            Implementation

            First of all, if we want to attach different types of event handles (member functions with same types of parameters from different classes) to the same event, we should provide common base for them. We use templates to make it generic for any combination of parameter types in ?delegate? or call back method. There are different event types for every number of arguments in callback function.

            Collapse Copy Code
            // Event handler base for delegate with 1 parameter
            template <typename ReturnT,typename ParamT>
            class EventHandlerBase1
            {
            public:
            virtual ReturnT notify(ParamT param) = 0;
            };

            Specific type of member function pointer within a pointer to the object is stored in the derived class.

            Collapse Copy Code
            template <typename ListenerT,typename ReturnT,typename ParamT>
            class EventHandler1 : public EventHandlerBase1<ReturnT,ParamT>
            {
            typedef ReturnT (ListenerT::*PtrMember)(ParamT);
            ListenerT* m_object;
            PtrMember m_member;
            public:
            EventHandler1(ListenerT* object, PtrMember member)
            : m_object(object), m_member(member)
            {}
            ReturnT notify(ParamT param)
            {
            return (m_object->*m_member)(param);
            }
            };

            Event class stores map of event handlers and notifies all of them when notify method is called. Detach method is used to release handler from the map.

            Collapse Copy Code
            template <typename ReturnT,typename ParamT>
            class CppEvent1
            {
            typedef std::map<int,EventHandlerBase1<ReturnT,ParamT> *> HandlersMap;
            HandlersMap m_handlers;
            int m_count;
            public:
            CppEvent1()
            : m_count(0) {}
            template <typename ListenerT>
            CppEventHandler attach(ListenerT* object,ReturnT (ListenerT::*member)(ParamT))
            {
            typedef ReturnT (ListenerT::*PtrMember)(ParamT);
            m_handlers[m_count] = (new EventHandler1<ListenerT,
            ReturnT,ParamT>(object,member));
            m_count++;
            return m_count-1;
            }
            bool detach(CppEventHandler id)
            {
            HandlersMap::iterator it = m_handlers.find(id);
            if(it == m_handlers.end())
            return false;
            delete it->second;
            m_handlers.erase(it);
            return true;
            }
            ReturnT notify(ParamT param)
            {
            HandlersMap::iterator it = m_handlers.begin();
            for(; it != m_handlers.end(); it++)
            {
            it->second->notify(param);
            }
            return true;
            }
            };

            Comments

            This implementation is quite similar to those in the article ?Emulating C# delegates in Standard C++?. I found out it after I already wrote the article. Actually, the fact that we have a similar way to deal with the problem means that it?s a very intuitive solution for this kind of problem in C++. An advantage of the current implementation is that it supports different number of arguments, so any member function of any class could be a callback (delegate). Probably to have this thing as a part of standard library is a good thing, but even if it?s not a part of the standard, you can use it as it is. This implementation is restricted to events up to 3 parameters, it can be easily extended to other numbers by just rewriting it with different number of parameters (see code for details).

            License

            posted on 2009-07-22 14:51 yanghaibao 閱讀(492) 評論(0)  編輯 收藏 引用

            導航

            <2025年7月>
            293012345
            6789101112
            13141516171819
            20212223242526
            272829303112
            3456789

            統計

            常用鏈接

            留言簿

            隨筆分類

            隨筆檔案

            文章檔案

            收藏夾

            Good blogs

            搜索

            最新評論

            閱讀排行榜

            評論排行榜

            色婷婷综合久久久久中文字幕| 久久精品国产精品亚洲人人| 少妇久久久久久久久久| 久久综合久久自在自线精品自| 老色鬼久久亚洲AV综合| 国产成人久久精品一区二区三区| 久久九九全国免费| 亚洲午夜无码AV毛片久久| 久久99国产综合精品| 很黄很污的网站久久mimi色| 2020久久精品亚洲热综合一本| 国产成人精品白浆久久69| 久久午夜福利电影| 99久久综合狠狠综合久久止| 香蕉99久久国产综合精品宅男自 | 人人狠狠综合久久88成人| 日本精品久久久久中文字幕8| 欧美国产成人久久精品| 精品综合久久久久久88小说| 亚洲va国产va天堂va久久| 天天做夜夜做久久做狠狠| 国产毛片久久久久久国产毛片| 亚洲国产另类久久久精品黑人 | 久久久久中文字幕| 亚洲欧美成人综合久久久| 亚洲v国产v天堂a无码久久| 久久精品国产一区二区三区日韩| 亚洲精品国产美女久久久| 色播久久人人爽人人爽人人片AV| 国产国产成人久久精品| 免费观看成人久久网免费观看| 久久久久亚洲AV无码专区体验| 欧美激情一区二区久久久| 亚洲欧洲精品成人久久曰影片 | 伊人久久免费视频| 人人狠狠综合久久亚洲88| 色偷偷偷久久伊人大杳蕉| 日本五月天婷久久网站| 久久这里只精品99re66| 中文字幕无码久久人妻| 久久亚洲国产精品成人AV秋霞|