在MFC的消息映射表的建立中，通过一组宏，你就可以让自己的类先于父类处理某些Windows消息，这种行为很像虚函数，只是我们重载的内容不是虚函数，而是消息。

推动消息的泵

第一阶段 窗口过程

在产生一个窗口的时候，会调用CFrameWnd::Create，所有的故事也都从这里展开。下面的代码为了简洁，去掉了不相关的代码

BOOL CFrameWnd::Create(…)  {
     //  …
     if  ( ! CreateEx(…))  {
         //  …
    }
     //  …
}

BOOL CWnd::CreateEx(…)  {
     //  …
    AfxHookWindowCreate( this );
    HWND hWnd  =  ::CreateWindowEx(…);
     //  …
}

void  AFXAPI AfxHookWindowCreate(CWnd *  pWnd)  {
     //  …
     if  (pThreadState -> m_hHookOldCbtFilter  ==  NULL)  {
        pThreadState -> m_hHookOldCbtFilter  =  ::SetWindowsHookEx(WH_CBT,
        _AfxCbtFilterHook, NULL, ::GetCurrentThreadId());
         //  …
    }
     //  …
    pThreadState -> m_pWndInit  =  pWnd;
}

这样，通过AfxHookWindowCreate，在当前线程中安装了一个钩子，用来拦截和窗口相关的事件，每当：

1. 另一个窗口成为active；
2. 产生或摧毁一个窗口
3. Minimize或maximize一个窗口；
4. 移动或缩放一个窗口；
5. 完成一个来自系统菜单的命令；
6. 从系统队列中取出一个消息；

时，都会先调用_AfxCbtFilterHook，接下来看看钩子函数作了什么：

LRESULT CALLBACK
_AfxCbtFilterHook( int  code, WPARAM wParam, LPARAM lParam)  {
     //  …
    WNDPROC afxWndProc  =  AfxGetAfxWndProc();
    oldWndProc  =  (WNDPROC)SetWindowLongPtr(hWnd, GWLP_WNDPROC,(DWORD_PTR)afxWndProc);
     //  …
}

WNDPROC AFXAPI AfxGetAfxWndProc()  {
     //  …
     return   & AfxWndProc;
}

这样，_AfxCbtFilterHook的工作总结起来就是通过窗口子类化，把新建的窗口的窗口过程设置成AfxWndProc。
到这里，我们终于找到了窗口过程。

结论
CFrameWnd::Create创建窗口调用CWnd::CreateEx
CWnd::CreateEx调用AfxHookWindowCreate准备为窗口设置钩子
AfxHookWindowCreate调用::SetWindowHookEx为窗口设置了一个WH_CBT类型的钩子来过滤消息，并把过滤函数设置成_AfxCbtFilterHook
_AfxCbtFilterHook通过窗口子类化设置窗口的窗口过程为AfxWndProc
这样，通过::DispatchMessage发送给窗口的消息就会源源不断地送到AfxWndProc中来，可以想到，AfxWndProc利用MFC的消息映射表，分门别类的对消息进行分流。

（待续……）

struct  AFX_MSGMAP_ENTRY
{
　　UINT nMessage;    //  windows message
　　UINT nCode;      　 //  control code or WM_NOTIFY code
　　UINT nID;        　　 //  control ID (or 0 for windows messages)
　　UINT nLastID;    　 //  used for entries specifying a range of control id's
　　UINT_PTR nSig;   　 //  signature type (action) or pointer to message #
　　AFX_PMSG pfn;     //  routine to call (or special value)
} ;

其中　typedef void (AFX_MSG_CALL CCmdTarget::*AFX_PMSG)(void);

之后，通过一个链表，把这些描述消息的结构组织起来，构成消息映射表的结构是AFX_MSGMAP

struct  AFX_MSGMAP　 {
　　 const  AFX_MSGMAP *  pBaseMap;
　　 const  AFX_MSGMAP_ENTRY *  lpEntries;
} ;

这样一个AFX_MSGMAP对象就成了构建消息映射表的关键人物，它一只手拉着基类的AFX_MSGMAP对象，另一只手拉着类本身的消息映射表，这样只要正确地在每一个类中都安插一个AFX_MSGMAP对象，那么整个消息映射表就建立起来了。那么，何为正确呢？含义有2：一是正确的设置pBaseMap，令它指向基类，二是正确的建立类自身的消息映射表。这两个工作是由4个宏完成的，

它们是：DECLARE_MEMSSAGE_MAP() / BEGIN_MESSAGE_MAP() / ON_COMMAND()（注：ON_COMMAND宏只是为了处理命令消息，对于其它的消息还有对应的宏，但是原理是相同的） / END_MESSAGE_MAP()。
让我们一个个的看看：

#define  DECLARE_MESSAGE_MAP() \
private : \
　　 static   const  AFX_MSGMAP_ENTRY _messageEntries[]; \
protected : \
　　 static   const  AFX_MSGMAP messageMap; \
　　 virtual   const  AFX_MSGMAP *  GetMessageMap()  const ; \

这个宏的作用有3：
 1. 在类中插入一个静态成员_messageEntries，这是用来存放类要处理的消息的数组（即类本身的消息映射表）
 2.  另一个静态成员massageMap用来指向基类的消息映射表
 3. 安插一个虚函数，其内容有待实现

接下来，_messageEntries的初始化，messageMap的正确指向，GetMessageMap函数的实现这些工作还都没做，那正是后三个宏的责任，它们要顺序使用，方能工作正常。

#define  BEGIN_MESSAGE_MAP(theClass, baseClass) \
   const  AFX_MSGMAP *  theClass::GetMessageMap()  const  \
   {  return   & theClass::messageMap; }  \
  AFX_COMDAT  const  AFX_MSGMAP theClass::messageMap  =  \
   {  & baseClass::messageMap,  & theClass::_messageEntries[ 0 ] } ; \
  AFX_COMDAT  const  AFX_MSGMAP_ENTRY theClass::_messageEntries[]  =  \
  { \

这个宏的作用有3：
1. 定义了安插在类中的虚函数GetMessageMap()，只是简单的返回messageMap对象的地址
2. 初始化messageMap，把派生类和基类联系起来构成一个大的消息映射表
3. 为类本身的消息映射表的初始化做语法准备

ON_COMMAND这个宏的作用就是向_messageEntries数组中添加类本身要处理的命令消息，其实在MFC中还有很多更方便的宏可以向类中添加消息，例如OM_WM_PAINT等，这里，我们主要讨论ON_COMMAND，毕竟原理都是相同的。

#define  ON_COMMAND(id, memberFxn) \
{ WM_COMMAND, CN_COMMAND, (WORD)id, (WORD)id, AfxSigCmd_v, \
  static_cast < AFX_PMSG >  (memberFxn) } ,

无非是对AFX_MSG_ENTRY结构的初始化，这样在类中为每一个想要处理的消息都是用一个ON_COMMAND宏，就自动的初始化了类本身的消息映射表。

最后，当全部的信息添加完毕后，使用END_MESSAGE_MAP()宏通知MFC一个类消息映射表结束了。

#define  END_MESSAGE_MAP() \
   { 0 ,  0 ,  0 ,  0 , AfxSig_end, (AFX_PMSG) 0  }  \
 }; \

实现手法单纯得很，无非是一个全0的AFX_MESSAGE_MAP对象。

结论
想要让你的类处理某个消息，使用下面的组合：

BEGIN_MESSAGE_MAP(theClass, the  base  Class)
// 消息处理宏
END_MESSAGE_MAP()

答案也许让你有些惊讶，我们可以利用sizeof来帮忙。你可以把sizeof用在任何复杂的表达式上， sizeof可以返回这个表达式值的大小，而不会在运行时评估表达式的值。这也就意味着，你可以把函数重载、模版实例化、转换规则等等所有你可以在C++表达式中使用的设施统统塞到sizeof中来。实际上，sizeof隐藏了一个可以演绎表达式类型的设施，最终，sizeof会返回表达式结果的类型。

这样我们就可以通过sizeof和重载函数来解决判断类型之间的可转换性的问题。思路很简单：我们提供2个重载函数，一个函数的参数是我们要转换成的类型（我们用U表示），而另一个则用来接收其他所有类型的参数。然后我们把要检测的类型（用T表示）传递给重载函数。如果接受类型U为参数的函数被调用了，我们就认为T可以转换为U，反之则不可以。如何确定哪个函数被调用了呢？我们利用sizeof出马，我们只要让重载函数返回不同的类型，然后检查一下返回值就可以了。

实践一下：

首先，定义2个不同的类型：

typedef  char  Small;
class  Big  {  char  dummy[ 2 ]; } ;

默认情况下， sizeof(Small) 是 1 ，而 Big 的大小则无关紧要，我们只要知道肯定不是 1 就好了。

其次，定义 2 个重载函数，一个接收要转换成的类型：

Small Test(U);

另一个用来接收“其他的所有类型”，我们要保证在排除所有的转换之后才调用这个函数， OK, 用省略号表示的参数列表真好满足需求

Big Test(...);

尽管把一个 C++ 对象传递给 ... 参数类型的函数，其结果未定义，但是实际上我们并没有调用这个函数。我们甚至可以不用实现它。

最后，我们用 sizeof 判断一下就完成任务了：

const   bool  convExist  =   sizeof (Test(T()))  ==   sizeof (Small);

你也许会说，就是它了！ Test 的调用会创建一个临时对象 T ，之后可能的结果只能是 sizeof(Small) 或 sizeof(Big) 。兴奋之余，我们还要看到一个问题。如果 T 的构造函数被设计成 private ，我们就前功尽弃了。当然解决的方法也很简单，定义一个函数，让他返回类型为 T 的对象。

T MakeT();
const   bool  convExist  =   sizeof (Test(MakeT()))  ==   sizeof (Small);

最后，把刚才的东西封装到一个类里：

template  < class  T,  class  U >
class  Conversion  {
    typedef  char  Small;
     class  Big  {  char  dummy[ 2 ]; } ;

     static  Small Test(U);
     static  Big Test();
     static  T MakeT();

public :
     enum   { exist  =   sizeof (Test(MakeT()))  ==   sizeof (Small) } ;
} ;

另外，我们还可以设置另外一个常量 Conversion::SameType ，如果 T 和 U 表示同一个类型，那么返回 true ：

template  < class  T,  class  U >
class  Conversion  {
    ..  as  above..
     enum   { sameType  =   false }
} ;

之后为同一个类型设计一个偏特化版本：

template  < class  T >
class  Conversion < T, T >   {
     enum   { exists  =   1 , sameType  =   1  } ;
} ;

最后，回到我们的主题，通过 Conversion 的帮助，我们可以来决定两个类型的继承性了。

#define  SUPERSUBCLASS(T, U) \
    (Conversion < const  U * ,  const  T * )::exists  &&  \
     ! Conversion < const  T * ,  const   void *> ::sameType)

当 U 继承于 T 或者 U 和 T 是同一个类型的时候， SUPERSUBCLASS 返回 true 。总结一下，只有下面这 3 种情形 const U* 可以隐式转换到 const T* ：

1.      T 和 U 是同一个类型

2.      T 是 U 的任意一个基类

3.      T 是 void

我们通过第 2 个测试屏蔽了最后一种情形。当然，如果你认为同一种类型也不算是继承关系的话，可以进一步严格其条件：

#define  SUPERSUBCLASS_STRICT(T, U) \
    (SUPERSUBCLASS(T, U)  &&  \
     ! Conversion( const  T,  const  U)::sameType)

什么时候一个空的class不是空的？C++会在何时做些什么事情？如果你不声明它们，编译器会为你声明它们自己的拷贝构造函数、一个赋值运算符和一个析构函数。另外，如果你不声明一个构造函数，编译器还会为你创建一个。所有这些自动生成的函数都是public和inline的。例如，如果你写下：

class Empty {};

这和你写下如下的代码本质上是一样的：

class Empty {

    Empty() {…} // default constructor

    Empty(const Empty& rhs) {…} // Copy constructor

    ~Empty() {…}  // destructor - whether it's virtual?

    // copy assignment operator

    Empty& operator=(const Empty& rhs) {}

}

当然，这些函数只有它们真正被需要的时候才会被创建。下面这些情况会使得这些函数被创建：

Empty e1; // default constructor & destructor

Empty e2(e1); // copy constructor

e2 = e1; // copy assignment operator

既然编译器会为你创建这些函数，那么这些函数都做些什么工作呢？默认的构造和析构函数主要是让编译器放置一些执行“幕后工作”的代码，例如调用基类和非静态数据成员的构造和析构函数等。需要注意的是编译器为你生成的这个析构函数并不是虚拟的，除非这个类的基类明确声明了一个虚拟的析构函数。

对于拷贝构造函数和赋值运算符，编译器生成的版本只是简单的copy每一个非静态数据成员。例如，考虑一个名为NamedObject的模板,它可以让你把名字和类型T关联起来。

template <typename T>

class NamedObject {

public :

    NamedObject(constchar* name, const T& value);

    NamedObject(const std::string& name, const T& value);

private :

    std::string nameValue;

    T objectValue;

};

由于NamedObject中声明了构造函数，编译器便不会再自做主张为你生成一个默认的。这是很重要的。这意味着如果你精心设计的类的构造方式，你就不用再去担心编译器会愚蠢的为你添加一个不带参数的构造函数而破坏你的设计。

NamedObject 中既没有声明拷贝构造函数也没有声明赋值运算符，所以当需要的时候，编译器会自动为你生成。显然，下面的代码需要拷贝构造函数的支持：

NamedObject<int> no1("Smallest Prime Number", 2);

NamedObject<int> no2(no1);

编译器生成的拷贝构造函数必须要使用no1.nameValue和no1.objectValue来初始化no2中对应的成员。由于nameValue的类型是string，并且标准的string有一个拷贝构造函数，所以no2.nameValue就可以通过string的拷贝构造函数完成。另外objectValue是一个整数，对于这个内置类型，简单的bit-copy就可以完成复制的任务了。

其实，如果需要的话，编译器会按照和上面提到的相同的手法来为NamedObject来生成一个赋值运算符。但是，只有当生成的代码在语法和语义都都正确的时候，编译器才会为你执行生成工作，如果其中任何一方面除了问题，编译器就会拒绝为你重载operator =。

例如：如果我们这样定义NamedObject：

template <typename T>

class NamedObject {

public :

    NamedObject(const std::string& name, const T& value);

private :

    std::string& nameValue;

    const T objectValue;
};

之后，下面的代码会怎样呢？

std::string newDog("Persephone");

std::string oldDog("Satch");

NamedObject<int> p(newDog, 2);

NamedObject<int> s(oldDog, 36);
p = s; // What should happen?

在复制前，p.nameValue和s.nameValue分别指向不同的string对象。这个复制应该对p.nameValue做怎样的改变呢？直觉上，p.nameValue将会指向s.nameValue所指的string对象。但是这破坏了C++的一条基本的准则，C++不允许引用指向不同的对象。换句话说，难道改变p.nameValue所引用的对象应该要影响到其它对象所引用的字符串吗？这是编译器生成的赋值运算符应该做的事情吗？

C++ 对于这个问题的解答方法是拒绝编译这样的代码。如果你想让含有引用数据成员的类支持赋值功能，那么你就必须自己定义赋值运算符。对于含有const数据成员的类来说，故事是类似的。修改对象中的const成员总是非法的，所以编译器对于如何处理这种问题一无所知。最后，如果基类把operator=声明为private，那么编译器同样会拒绝为派生类生成operator=。毕竟，一方面，即便编译器可以生成，operator=也只能处理派生类中属于基类的那一部分；另一方面，派生类也根本无权访问基类中的private成员。

时时刻刻让自己记住

l          编译器会在必要的时候隐式生成类的默认构造函数、拷贝构造函数、operator=和析构函数。