MFC消息映射的通俗演绎

面向对象设计中，消息的传递是整个系统中非常重要的一环。ObjectC有runtime运行时来负责消息的传递和处理。不过这里不打算说oc的runtime，先来看看微软的天才工程师们是如何解决这个问题。
当消息发生时，寻找到合适的对象的方法去处理，这个过程很容易就联想到面向对象中的多态和继承。于是不假思索就得出一个解决方案。在基类中定义好虚函数，有子类去负责具体实现。那样大约会产生如下的代码:

class CCmdTarget
{
.....
public:
virtual void OnDraw();
virtual void OnClick();
virtual void OnKeyBoard();
.....
};

对于每一个能想到的消息，都在基类中写一个对应的虚函数，留作子类去重写。这样问题貌似得到了解决，不过效率不言而喻，每个对象都要持有一份长长的虚函数表。另外，如果将来有新的消息类型还不得不在基类中添加一个虚函数。
换个思路。消息映射，消息路由。这些字眼都在提醒着我们，我们需要一张表，这张表记录了每一条消息我们该交由谁处理。于是表里的条目应该是这样的结构体（精简了结构体，只取了几个重要的字段，名称还是原封不动的沿袭了MFC。）:

class CCmdTarget;
typedef void (CCmdTarget:: * AFX_PMSG)(void);
struct AFX_MSGMAP_ENTRY
{
    int nMessage;
    int nCode;
    AFX_PMSG pfn;
};

pfn是一个函数指针，其余两个是关于消息的。有了这样一张表，当有消息的时候，我们只需要查找一遍表，然后就可以知道该有哪个函数来处理。接下来我们再考虑另一个问题，当某个消息当前类不打算处理，或者基类中存在统一的处理办法，我们想交由它来处理该怎么整？这里就涉及到自顶向下（由子类到父类的传递）的递归。大致是这样的过程，在当前类中找处理函数，如果找不到，就到父类的表中去找，还是找不到，继续,直到找到，或者到达根类依然找不到就抛弃或者其他处理。这就需要我们在子类中保存有到达父类表的方法。这就像链表，为了形成链表，我们需要在节点中保存后继节点的指针。于是我们定义如下结构体:

struct AFX_MSGMAP
{
    const AFX_MSGMAP       * (*pfnGetBaseMap)();
    const AFX_MSGMAP_ENTRY * lpEntries;
};

第一个是获得父类表的函数指针，第二个就是 表的入口地址。接下来我们定义一个函数用来取得这些数据。

virtual const AFX_MSGMAP * GetMessageMap()const;

定义成虚函数的原因大家想必都明白，为了获得具体对象的路由表，这就是多态的思想。

const AFX_MSGMAP * CCmdTarget::GetMessageMap()const
{
    return GetThisMessageMap();
}

函数直接返回了另一个函数的返回值，我们来看下这个函数又是如何定义的。

static const  AFX_MSGMAP * GetThisMessageMap();
const AFX_MSGMAP * CCmdTarget::GetThisMessageMap()
{
    static const AFX_MSGMAP_ENTRY _messageEntries[] =
    {
        {0,0,(AFX_PMSG)0}
    };
    static const AFX_MSGMAP messageMap = {
        &CCmdTarget::GetThisMessageMap,&_messageEntries[0]
    };
    return & messageMap;
}

定义了局部静态变量，然后将直接将地址返回。这种设计也是性能考虑。静态变量只初始化一次就在进程的整个生命周期里存在于内存中。如果要问为啥要大费周章的设计两个函数，一个函数的使命竟然只是为了调用另外一个函数。我的思路是，GetMessageMap设计成虚函数的用意很明显，为了实现多态，每个对象都要获得自己的路由表，这种根据不同的对象有不同的实现就是多态的思想。另外AFX_MSGMAP结构体的第一个字段就是一个函数指针，这个函数指针是普通的函数指针，而不是一个指向类成员函数的指针。没有设计成指向类成员函数指针的原因是，类成员函数的指针在调用时必须要加上对象地址。这就使得我们必须在每个对象中保存一个父类对象的地址。这显然是不切实际的，对象都还没创建出来，我们怎么去保存这个地址呢。于是我们需要一个编译期就能确定的函数地址。这也就是static const AFX_MSGMAP * GetThisMessageMap()被定义为静态函数的原因。因为我们在编译期就需要它的地址啊。我们将父类的函数地址存放AFX_MSGMAP结构体中。就可以实现 运行时通过多态的GetMessageMap函数获得一个AFX_MSGMAP结构体，而这个结构体中又有一个父类的获得AFM_MSGMAP的函数的指针。这就形成了一个反向链表结构。
至于如何路由，我随意写了一个函数，可供参考:

void HandleMessage(int nMessage,int nCode)
    {
        const AFX_MSGMAP * msg_map      = this->GetMessageMap();
        const AFX_MSGMAP * (* pfnGetBaseMap)();
        
        while(msg_map != NULL)
        {
            const AFX_MSGMAP_ENTRY * msg_entry = msg_map->lpEntries;
            while ( !(msg_entry->nCode == 0 && msg_entry->nMessage== 0) )
            {
                if(msg_entry->nMessage == nMessage && msg_entry->nCode == nCode)
                {
                    AFX_PMSG p2fn = msg_entry->pfn;
                    (this->*p2fn)();
                }
                msg_entry ++;
            }
            ///refresh msg_map , base_msg_map
            pfnGetBaseMap = msg_map->pfnGetBaseMap;
            msg_map = pfnGetBaseMap==NULL?NULL:(*pfnGetBaseMap)();
        }
    }

像伪代码一样直白，就是在本类的路由表里搜索一下 找不到就继续去父类找。这就是MFC消息映射的一点个人理解。下面贴一下 样例代码。仅供参考。至于DECLARE_MESSAGE_MAP BEGIN_MESSAGE_MAP这些宏就不说了，那都不是重点。

class CCmdTarget;
typedef void (CCmdTarget:: * AFX_PMSG)(void);
struct AFX_MSGMAP_ENTRY
{
    int nMessage;
    int nCode;
    AFX_PMSG pfn;
};
struct AFX_MSGMAP
{
    const AFX_MSGMAP       * (*pfnGetBaseMap)();
    const AFX_MSGMAP_ENTRY * lpEntries;
};
class CCmdTarget
{
protected:
    static const  AFX_MSGMAP * GetThisMessageMap();
    virtual const AFX_MSGMAP * GetMessageMap()const;
public:
    void HandleMessage(int nMessage,int nCode)
    {
        const AFX_MSGMAP * msg_map      = this->GetMessageMap();
        const AFX_MSGMAP * (* pfnGetBaseMap)();
        
        while(msg_map != NULL)
        {
            const AFX_MSGMAP_ENTRY * msg_entry = msg_map->lpEntries;
            while ( !(msg_entry->nCode == 0 && msg_entry->nMessage== 0) )
            {
                if(msg_entry->nMessage == nMessage && msg_entry->nCode == nCode)
                {
                    AFX_PMSG p2fn = msg_entry->pfn;
                    (this->*p2fn)();
                }
                msg_entry ++;
            }
            ///refresh msg_map , base_msg_map
            pfnGetBaseMap = msg_map->pfnGetBaseMap;
            msg_map = pfnGetBaseMap==NULL?NULL:(*pfnGetBaseMap)();
        }
    }
private:
    void OnDraw()
    {
        cout << "this is CCmdTarget::OnDraw()" << endl;
    }
};
const AFX_MSGMAP * CCmdTarget::GetMessageMap()const
{
    return GetThisMessageMap();
}
const AFX_MSGMAP * CCmdTarget::GetThisMessageMap()
{
    static const AFX_MSGMAP_ENTRY _messageEntries[] =
    {
        {100,100,(AFX_PMSG)&CCmdTarget::OnDraw},
        {0,0,(AFX_PMSG)0}
    };
    static const AFX_MSGMAP messageMap = {
        /*&CCmdTarget::GetThisMessageMap*/NULL,&_messageEntries[0]
    };
    return & messageMap;
}
//////////////////////////////////////////////////////////////
class CWind:public CCmdTarget
{
protected:
    static const  AFX_MSGMAP * GetThisMessageMap();
    virtual const AFX_MSGMAP * GetMessageMap()const;
};
const AFX_MSGMAP * CWind::GetMessageMap()const
{
    return GetThisMessageMap();
}
const AFX_MSGMAP * CWind::GetThisMessageMap()
{
    static const AFX_MSGMAP_ENTRY _messageEntries[] =
    {
        {0,0,(AFX_PMSG)0}
    };
    static const AFX_MSGMAP messageMap = {
        &CCmdTarget::GetThisMessageMap,&_messageEntries[0]
    };
    return & messageMap;
}

int main(int argc, const char * argv[])
{
    CWind win7;
    win7.HandleMessage(100, 100);
}