消息映射深度探索

最新推荐文章于 2024-07-24 00:31:40 发布
转载 最新推荐文章于 2024-07-24 00:31:40 发布 · 873 阅读 · 2
文章标签：

#class #mfc #struct #pair #设计模式 #null

消息映射深度探索(1)：基础面

消息映射这项技术，给消息横向(多个类对象)或纵向(继承树)流动的机会。

 

 

此技术最初之发展动机是为了简化win32程序的消息处理过程，后来也被应用到网络程序的消息处理。一旦某个消息到达win32消息处理函数，此函数就会 使用一个switch...case映射网将此消息映射至相应处理函数。switch...case具有与生俱来的缺点：难于扩展，效率低下。随着消息的 增多，switch...case将变得庞大而不堪重负。消息映射可以解决这个问题，因为当对象运用了消息映射技术后，对象自己就能够处理消息（或者说对外界宣告，我能处理这个消息，请把它交给我处理）。

 

消息映射架构在一大堆有趣的细节之上。在深入到细枝末节前，先让我们看下基础面：传统的不使用消息映射程序是如何实作的？下面是一种可能：

void HandleMessage( Message* message ) {

    switch ( message->GetID() ) {

        case MessageID_A:

            FunctionA( message );

            break;

        ...

        case MessageID_N:

            FunctionN( message );

            break;

        default:

            assert( false && "Unknown message" );

    }

}

 

这个做法几乎不具备任何扩展性，如果HandleMessage()被封装到库中那就意味着用户不再有任何修改的机会，那么用户该如何针对自己喜爱的消息做特殊处理,而忽略那些不打算处理的消息呢？

 

继续前行之前，我们先来了解几个将被使用的宏：

 

#include <iostream>

 

#define PRINT( msg ) { std::cout << msg << std::endl; }

#define FUNC( func ) void func() { PRINT( #func##"()" ); }

#define MFUNC( class, func ) void func() { PRINT( #class##"::"###func##"()" ); }

#define VMFUNC( class, func ) virtual MFUNC( class, func )

 

namespace AutoTest {

    FUNC( func );

 

    struct TestStruct {

        MFUNC( TestStruct, func );

        VMFUNC( TestStruct, vfunc );

    };

   

    void TestPRINT() {

        PRINT( "PRINT()" );

        func();

        TestStruct t;

        t.func();

        t.vfunc();

    }

}

 

void main() {

    AutoTest::TestPRINT();

}

 

这里列出了一些宏，用于打印或者产生一些简单的全局打印函数或者成员函数。

 

消息映射深度探索(2)：MFC的做法 - 使用消息映射表

在MFC被成功做出来之前，一个最简单的想法就是使用虚函数，为每个消息定制一个虚函数，下面是个可能的实现：

 

#include <iostream>

#include <map>

#include <cassert>

 

#define PRINT( msg ) { std::cout << msg << std::endl; }

#define FUNC( func ) void func() { PRINT( #func##"()" ); }

#define MFUNC( class, func ) void func() { PRINT( #class##"::"###func##"()" ); }

#define VMFUNC( class, func ) virtual MFUNC( class, func )

 

enum MsgID {

    MsgID_1,

    MsgID_2,

};

 

namespace PreMFC {

    class Wnd;

    typedef void (Wnd::*MemberFunc)();

    typedef std::map< int, MemberFunc > MsgRegistry;   

 

    struct MsgMap {

        const MsgRegistry& thisMsgRegistry;

        const MsgMap* baseMsgMap;

    };

 

    class Wnd {

    public:

        void HandleMsg( int id ) {

            switch( id ) {

                case MsgID_1: Handle1(); break;

                case MsgID_2: Handle2(); break;

                default: break;

            }

        }

    private:

        VMFUNC( Wnd, Handle1 );

        VMFUNC( Wnd, Handle2 );

    };

 

    class MyWnd : public Wnd {

    private:

        VMFUNC( MyWnd, Handle1 );

    };

}

 

namespace AutoTest {

    void TestPreMFCMsgMap() {

        using namespace PreMFC;

        Wnd* wnd = new MyWnd;

        wnd->HandleMsg( MsgID_1 );

        wnd->HandleMsg( MsgID_2 );

    }

}

 

void main() {

    AutoTest::TestPreMFCMsgMap();

}

 

不幸的是，这个做法太耗内存，每个类都将有一个和基类一模一样的庞大的vtable，此table内含所有虚函数指针。

下面我们看下MFC是如何实现消息映射的：

 

...

 

namespace MFC {

    class Wnd;

    typedef void (Wnd::*MemberFunc)();

    typedef std::map< int, MemberFunc > MsgRegistry;   

 

    struct MsgMap {

        const MsgRegistry& thisMsgRegistry;

        const MsgMap* baseMsgMap;

    };

 

    class Wnd {

    public:

        void HandleMsg( int id ) {           

            const MsgMap* msgMap = &GetMsgMap();

            assert( msgMap != NULL );

 

            while ( msgMap != NULL ) {               

                const MsgRegistry& registry = msgMap->thisMsgRegistry;

                MsgRegistry::const_iterator it = registry.find( id );

                if ( it != registry.end() ) {

                    ( this->*( it->second ) )();

                    break;

                }

                msgMap = msgMap->baseMsgMap;

            }           

        }

 

    protected:

        virtual const MsgMap& GetMsgMap() const {

            static MsgMap msgMap = {

                GetInitilizedMsgRegistryWnd(),

                NULL

            };

            return msgMap;

        }

 

    private:

        MsgRegistry& GetInitilizedMsgRegistryWnd() const {

            static MsgRegistry thisMsgRegistry;

            thisMsgRegistry.insert( std::make_pair( MsgID_1, &Wnd::Handle1 ) );

            thisMsgRegistry.insert( std::make_pair( MsgID_2, &Wnd::Handle2 ) );

            return thisMsgRegistry;

        }

 

    private:

        MFUNC( Wnd, Handle1 );

        MFUNC( Wnd, Handle2 );

    };

 

    class MyWnd : public Wnd {

    protected:

        virtual const MsgMap& GetMsgMap() const {

            static MsgMap msgMap = {

                GetInitilizedMsgRegistryMyWnd(),

                &Wnd::GetMsgMap()

            };

            return msgMap;

        }

    private:

        MsgRegistry& GetInitilizedMsgRegistryMyWnd() const {

            static MsgRegistry thisMsgRegistry;

            thisMsgRegistry.insert( std::make_pair( MsgID_1, (MemberFunc)&MyWnd::Handle1 ) );           

            return thisMsgRegistry;

        }

 

    private:

        MFUNC( MyWnd, Handle1 );

    };

}

 

namespace AutoTest {

    void TestMFCMsgMap() {

        using namespace MFC;

        Wnd* wnd = new MyWnd;

        wnd->HandleMsg( MsgID_1 );

        wnd->HandleMsg( MsgID_2 );

    }

}

 

void main() {

    AutoTest::TestMFCMsgMap();

}

 

原理

 

1. 建立消息映射表

每个类以GetInitilizedMsgRegistry##Class()产生一个static映射表，并与基类之映射表做链接（GetMsgMap()内）

 

2. 迭代查找消息函数

消息映射起源于Wnd::HandleMessage函数，此函数将在整个继承链的消息映射网中搜寻id对应之处理函数，首先从叶端找起（Template模式），一直到根端。

这是个迭代过程（下面我们还会讲到以递归实现的消息映射，但那要依赖于虚函数），速度很快。

 

细节

 

1. 看起来MyWnd::Handle1重写了Wnd::Handle1，这与EffectiveC++的建议相悖（不该重写非虚函数）。但这里是个例外，因为两个名字只是碰巧相同罢了（你完全可以用其他名字）

2. 不同于MFC的是，直接使用map来存储映射表而非数组(MFC的真正实现)，以简化搜寻操作(但是内存占用多了)。（MFC的搜寻操作为AfxFindMessageEntry，其内部不知使用什么技巧来加速查询）

3. 可以把派生类成员函数指针转换为基类成员函数指针，反过来不成立。(MemberFunc)&MyWnd::Handle1;

 

优缺点

 

使用消息映射表将会为每个类产生一个map，包含本类感兴趣的那些消息，占用内存可想而知比先前使用虚函数的方法要小很多，但是迭代的搜寻操会比直接调用虚函数的效率要低。

 

消息映射深度探索(3)：使用宏简化操作

消息映射网的建立可以用宏定义出来，以简化派生类的操作：

 

#include <iostream>

#include <map>

#include <cassert>

 

#define PRINT( msg ) { std::cout << msg << std::endl; }

#define FUNC( func ) void func() { PRINT( #func##"()" ); }

#define MFUNC( class, func ) void func() { PRINT( #class##"::"###func##"()" ); }

#define VMFUNC( class, func ) virtual MFUNC( class, func )

 

enum MsgID {

    MsgID_1,

    MsgID_2,

};

 

namespace MFCMacro {

    class Wnd;

    typedef void (Wnd::*MemberFunc)();

    typedef std::map< int, MemberFunc > MsgRegistry;    

 

    struct MsgMap {

        const MsgRegistry& thisMsgRegistry;

        const MsgMap* baseMsgMap;

    };

 

/* MACRO BEGIN *///////////////////////////////////////////////////////////

#define MSG_BEGIN( theClass, baseClass )                        /

protected:                                                      /

    virtual const MsgMap& GetMsgMap() const {                   /

        static MsgMap msgMap = {                                /

            GetInitilizedMsgRegistry##theClass(),               /

            &baseClass::GetMsgMap()                             /

        };                                                      /

        return msgMap;                                          /

    }                                                           /

private:                                                        /

    MsgRegistry& GetInitilizedMsgRegistry##theClass() const {   /

        static MsgRegistry thisMsgRegistry;                

 

#define MSG_ENTRY( id, func )                                   /

        thisMsgRegistry.insert( std::make_pair( id, (MemberFunc)func ) );

 

#define MSG_END()                                               /

        return thisMsgRegistry;                                 /

    }

/* MACRO END *////////////////////////////////////////////////////////////

 

    class Wnd {

        ...   

    };

 

    class MyWnd : public Wnd {

        MSG_BEGIN( MyWnd, Wnd )

            MSG_ENTRY( MsgID_1, &MyWnd::Handle1 )           

        MSG_END()

    private:

        MFUNC( MyWnd, Handle1 );       

    };   

}

 

namespace AutoTest {

    void TestMFCMacroMsgMap() {

        using namespace MFCMacro;

        Wnd* wnd = new MyWnd;

        wnd->HandleMsg( MsgID_1 );

        wnd->HandleMsg( MsgID_2 );

    }

}

 

void main() {

    AutoTest::TestMFCMacroMsgMap();

}

 

注意

 

为了表述方便，上面所示的宏直接将消息映射的定义部分放在类声明中。

你也可以像MFC那样将声明和实现分开：

 

声明

DECLARE_MESSAGE_MAP()

 

实现

BEGIN_MESSAGE_MAP()

 ON_WM_XXX()

 ON_COMMAND()

 ON_MESSAGE()

 ...

END_MESSAGE_MAP()

 

消息映射深度探索(4)：职责链模式 - 使用虚函数替换映射表

下面我们将介绍另一种实现消息映射的方式：职责链模式

 

#include <iostream>

#include <map>

#include <cassert>

 

#define PRINT( msg ) { std::cout << msg << std::endl; }

#define FUNC( func ) void func() { PRINT( #func##"()" ); }

#define MFUNC( class, func ) void func() { PRINT( #class##"::"###func##"()" ); }

#define VMFUNC( class, func ) virtual MFUNC( class, func )

 

enum MsgID {

    MsgID_1,

    MsgID_2,

};

 

namespace COR { // chain of responsibility

    class Wnd;

    typedef void (Wnd::*MemberFunc)();   

 

    class Wnd {

    public:

        virtual void HandleMsg( int id ) {

            switch ( id ) {

                case MsgID_1: Handle1(); break;

                case MsgID_2: Handle2(); break;

            }

        }

 

    private:

        MFUNC( Wnd, Handle1 );

        MFUNC( Wnd, Handle2 );

    };

 

    class MyWnd : public Wnd {

    public:

        virtual void HandleMsg( int id ) {

            switch( id ) {

                case MsgID_1: Handle1(); break;

                default: Wnd::HandleMsg( id );

            }

        }

 

    private:

        MFUNC( MyWnd, Handle1 );

    };   

}

 

namespace AutoTest {

    void TestCORMsgMap() {

        using namespace COR;

        Wnd* wnd = new MyWnd;

        wnd->HandleMsg( MsgID_1 );

        wnd->HandleMsg( MsgID_2 );

    }

}

 

void main() {

    AutoTest::TestCORMsgMap();

}

 

原理

 

不需要消息映射表，而是利用虚函数HandleMsg()向父类递归查找，详情可参考《设计模式》职责链模式。

 

细节

 

1. 可以把switch...case用查找表替换掉，但绝非必要。通常使用此法是在有封装之必要时才会采取的措施，详情可参考

http://blog.youkuaiyun.com/hjsunj/archive/2008/01/07/2028597.aspx

http://blog.youkuaiyun.com/hjsunj/archive/2008/01/11/2037354.aspx

 

2. 使用NVI模式（《Effective C++ 3rd》chapter35）让思路更加清晰，此时需借助查找表

将HandleMsg变为非虚函数：

void HandleMsg( int id ) {

    MemberFunc func = Lookup( id );

    if ( func != NULL ) {

        (this->*func)();

   }

}

virtual MemberFunc Lookup( int id ) {

    // 如果thisclass有id之处理函数，返回之  

    // 否则返回BaseClass::Lookup( id );

}

 

优缺点

 

1. 实现简单：不再需要定制宏，不再需要建立消息映射表，所需的只是重写虚函数。

2. 节省内存：由于不再需要为每个派生类准备查找表，节省内存是自然而然的事。

2. 效率低下： 通常使用虚函数的效率会高于查找表（《设计模式》p204），但那只对一次调用成立。职责链模式对虚函数递归调用，其时间开销必然要高于映射表方案的迭代查找。

 

总结

孰优孰劣

 

上面我们讨论了实现消息映射的两种方案：

 

1. 使用消息映射表

2. 使用虚函数

 

在效率上我们可以看出前者胜出，内存使用上后者胜出（前提是后者不使用查找表替换switch...case）。

所以看其来大家各有优劣。

 

使用消息映射表必然要使用宏，除非事先这些宏已经制作完成，否则如果写这样的宏必然是件非常痛苦的事情。所以消息映射表的方式通常被用在Framework的实作，比如MFC等。

 

而虚函数的制作相当方便，所以如果不是制作Framework的话，那么这个方案也是不错的。

 

更进一步的讨论：允许消息横流

 

作为Framework的实作者，你或许还需要让消息拥有横流的机会，即流向子系统而非父类。

 

 

 

一切皆是映射：Transformer模型深度探索
AI天才研究院
05-07 725
一切皆是映射：Transformer模型深度探索 1. 背景介绍 1.1 从序列到序列：机器翻译的演进 机器翻译，作为自然语言处理领域的重要任务，一直是人工智能研究的热点。早期的机器翻译方法主要基于统计机器翻译
一切皆是映射：探索神经网络的基本概念
最新发布
AI天才研究院
10-07 962
自从20世纪80年代以来，神经网络作为一种强大的机器学习模型，在各个领域都取得了显著的进展。然而，神经网络的本质是什么？它们是如何处理信息的？这些基本问题一直困扰着研究人员和工程师。本文旨在通过探讨神经网络的映射概念，帮助读者深入理解神经网络的基本原理和运作机制。映射是指将一个集合中的元素对应到另一个集合中的元素。在神经网络中，映射是指将输入数据映射到输出数据的过程。fX→YfX→Y其中，XX为输入空间，YY为输出空间，fff为映射函数。
MFC消息映射机制
HayPinF的博客
11-15 385
每个可以接收消息或命令的框架类(framework class)都有其自己的消息映射(messge map)，框架使用消息映射来连接消息或命令到其处理函数(handle function)，任何从CCmdTarget类派生的类都有消息映射(有CView视图类，CWinApp应用程序类，CDocument文档类，CWnd窗口类和CFrameWnd框架窗口类，这些CCmdTarget基类的派生类...
map/ multimap容器（键值对）
weixin_62848630的博客
07-24 1813
map和multimap。
pair 的用法
ACM
08-09 393
类模板 ： template&lt;class T1, class T2&gt; struct pair参数 ： T1是第一个值得数据类型，T2是第二个值得数据类型功能：pair将一对值组合成一个值，这一对值可以具有不同的数据类型（T1和T2）,两个值可以分别用pair的两个公共函数first和second访问具体用法1定义（构造）：pair&lt;int, double&gt; p1; //使...
C++基础(十一)：枚举类型、union
连理o的博客
11-13 999
本文为《C++ Primer》的读书笔记 目录限定 / 不限定 作用域的枚举枚举成员和类一样，枚举也定义新的类型指定`enum` 的大小枚举类型的前置声明形参匹配与枚举类型 限定 / 不限定 作用域的枚举 C++ 包含两种枚举： 限定作用域的 (scoped enumeration) (由 C++11 新标准引入) 定义限定作用域的枚举类型的一般形式是：首先是关键字enum class (或者等价地使用enum struct), 随后是枚举类型名字以及用花括号括起来的以逗号分隔的枚举成员列表： /
C++中的pair,make_pair学习
bingqingsuimeng的专栏
06-20 3317
std::pair主要的作用是将两个数据组合成一个数据，两个数据可以是同一类型或者不同类型。例如std::pair或者std：：pair等。pair实质上是一个结构体，其主要的两个成员变量是first和second，这两个变量可以直接使用。初始化一个pair可以使用构造函数，也可以使用std::make_pair函数，make_pair函数的定义如下： template pair make_pa
C++ 消息映射机制深度探索
06-28
C++ 消息映射机制深度探索
MyBatis：SQL映射框架的深度探索.pdf
05-28
### MyBatis：SQL映射框架的深度探索 #### 一、MyBatis的核心概念 - **SQL映射文件**：这是MyBatis的核心配置文件之一，它定义了SQL语句与Java方法之间的映射关系。通过XML文件或注解的方式，开发者可以明确指定...
一切皆是映射：深度学习的基石与概念入门
AI天才研究院
07-24 620
一切皆是映射：深度学习的基石与概念入门 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 1. 背景介绍 1.1 问题的由来 随着计算机技术的发展，数据量的爆炸
C++pair类型
weixin_33717298的博客
05-09 2256
标准库类型--pair类型定义在utility头文件中定义  本文地址：http://www.cnblogs.com/archimedes/p/cpp-pair.html，转载请注明源地址。 1、pair的创建和初始化 pair包含两个数值，与容器一样，pair也是一种模板类型。但是又与之前介绍的容器不同，在创建pair对象时，必须提供两个类型名，两个对应的类型名的类型不必相同 p...
MFC----Map使用。
qq_42095701的博客
05-09 4843
快速去除重复字符串并统计重复次数 static map<string, int> word_count; //存储GET容器 声明 static map<string, int>::iterator iter; //遍历链接迭代器 使用： //map去重统计操作 这里操作的 string word; if (v...
C++ pair的基本用法总结（整理）
热门推荐
sevenjoin的博客
08-22 55万+
1，pair的应用 pair是将2个数据组合成一组数据，当需要这样的需求时就可以使用pair，如stl中的map就是将key和value放在一起来保存。另一个应用是，当一个函数需要返回2个数据的时候，可以选择pair。 pair的实现是一个结构体，主要的两个成员变量是first second 因为是使用struct不是class，所以可以直接使用pair的成员变量。 其标准库类型--pair类......
C++ pair（对组）用法
weixin_33980459的博客
03-10 466
类模板：template &lt;class T1, class T2&gt; struct pair 参数：T1是第一个值的数据类型，T2是第二个值的数据类型。 功能：pair将一对值组合成一个值，这一对值可以具有不同的数据类型（T1和T2），两个值可以分别用pair的两个公有函数first和second访问。 具体用法： 1.定义（构造）： 1 pair&lt;int, ...
C++学习之Pair
xywlpo的专栏
06-01 9万+
Pair类型概述pair是一种模板类型，其中包含两个数据值，两个数据的类型可以不同，基本的定义如下：pair a;表示a中有两个类型，第一个元素是int型的，第二个元素是string类型的，如果创建pair的时候没有对其进行初始化，则调用默认构造函数对其初始化。pair a("James", "Joy");也可以像上面一样在定义的时候直接对其初始化。由于pair类型的使用比较繁琐，因为如果要定义多个形同的pair类型的时候，可以时候typedef简化声明：typedef pair author;author
C++之（pair）用法总结
楠国的鱼
06-30 1026
pair函数： 类模板： template <class T1, class T2> struct pair 参数：class T1是第一个值的数据类型，class T2是第二个值的数据类型。 功能：pair将一对值（可以是不同的数据类型）组合成一个值，两个值可以分别用pair的两个公有函数first和second访问。 具体用法： 1、定义pair<int,string>p1; //使
c++ 中 pair 的 使用方法
OceanLight的专栏
08-21 7万+
pair的类型：     pair 是 一种模版类型。每个pair 可以存储两个值。这两种值无限制。也可以将自己写的struct的对象放进去。。     pair p;     pair p;    pair p;   都可以。。。     应用：如果一个函数有两个返回值 的话，如果是相同类型，就可以用数组返回，如果是不同类型，就可以自己写个struct ，但为了方便就可以使用
MFC应用程序消息处理深度探索
如果不是，或者控制项拒绝映射消息，OnCommand会继续调用OnCmdMsg。 6. **OnCmdMsg**：OnCmdMsg是命令传递过程的核心，它可能将消息传递给框架类、视图类和文档类，以寻找合适的处理函数。这确保了消息能够在MFC...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值