MFC学习笔记

简介:

1 概述
本文档是在学习<<深入浅出>>MFC过程中临时写的一篇文档,并没有真正的深入。本文档结合VC9单文档程序来写的。
2 MFC六大技术
对应<<深入浅出MFC>>的第三章。
2.1 MFC程序的初始化过程
2.1.1 _tWinMain

 
  1. _tWinMain(…){    
  2. return AfxWinMain(…);    
  3. }   

从代码可以看到,该函数仅调用了AfxMain函数。
_tWinMain是被C/C++运行期函数调用的,这里暂不多讲,因为这部分很复杂。
2.1.2 AfxWinMain
看一下该函数代码,这里仅写主要的调用,将其它都省略掉。

 
  1. int AFXAPI AfxWinMain(…){  
  2. CWinThread* pThread = AfxGetThread();  
  3. CWinApp* pApp = AfxGetApp();  
  4. AfxWinInit(…);  
  5. pApp->InitApplication();  
  6. if (!pThread->InitInstance()){  
  7.    pThread->m_pMainWnd->DestroyWindow();  
  8.    nReturnCode = pThread->ExitInstance();  
  9.    goto InitFailure;  
  10. }  
  11. nReturnCode = pThread->Run();  
  12.  
  13. InitFailure:  
  14. #ifdef _DEBUG  
  15. // Check for missing AfxLockTempMap calls  
  16. if (AfxGetModuleThreadState()->m_nTempMapLock != 0)  
  17. {  
  18.    TRACE(traceAppMsg, 0, "Warning: Temp map lock count non-zero (%ld).\n",  
  19.     AfxGetModuleThreadState()->m_nTempMapLock);  
  20. }  
  21. AfxLockTempMaps();  
  22. AfxUnlockTempMaps(-1);  
  23. #endif  
  24. AfxWinTerm();   

2.1.3 AfxGetThread
    这个函数返回一个CWinThread类型指针,这实际上是一个全局对象的指针,该函数内部执行非常复杂,这里不讲。但可以知道,程序正式通过该指针管理线程的。
2.1.4 AfxGetApp
    返回CWinApp对象指针,这也是一个全局对象指针,有理由相信,该对象就是theApp这个全局对象。
2.1.5 AfxWinInit
看一下该函数简化的代码:
// handle critical errors and avoid Windows message boxes
SetErrorMode(…);
// set resource handles
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
pModuleState->m_hCurrentInstanceHandle = hInstance;
pModuleState->m_hCurrentResourceHandle = hInstance;
pModuleState->CreateActivationContext();
// fill in the initial state for the application
CWinApp* pApp = AfxGetApp();
// Windows specific initialization (not done if no CWinApp)
pApp->m_hInstance = hInstance;
App->m_lpCmdLine = lpCmdLine;
pApp->m_nCmdShow = nCmdShow;
pApp->SetCurrentHandles();
// initialize thread specific data (for main thread)
AfxInitThread();
// Initialize CWnd::m_pfnNotifyWinEvent
HMODULE hModule = ::GetModuleHandle(_T("user32.dll"));
CWnd::m_pfnNotifyWinEvent = 
(CWnd::PFNNOTIFYWINEVENT)::GetProcAddress(hModule, NotifyWinEvent");
从这个函数可以看出,该函数做了如下工作:
 设置错误模式。
 设置资源,这里先不做深入学习,这里很可能设置一个模块句柄,然后程序默认从该模块中读取资源。
 初始化CWinApp某些成员。
 AfxInitThread为主线程安装了一个WH_MSGFILTER类型的挂钩,并指定了一个挂钩函数_AfxMsgFilterHook,当消息来自于dialog box, message box, menu, or scroll bar时,系统就会调用挂钩函数,这里暂不研究挂钩函数。
 初始化类的CWnd静态函数指针m_pfnNotifyWinEvent,它指向模块user32.dll中的函数NotifyWinEvent,关于该函数参看msdn。
2.1.6 InitApplication
m_pDocManager = CDocManager::pStaticDocManager;
m_pDocManager->AddDocTemplate(NULL);
LoadSysPolicies();
该函数主要初始化了成员m_pDocManager。
LoadSysPolicies函数暂时不深入学习。
2.1.7 InitInstance
这个函数就不多说了。
2.1.8 Run
下面是该函数的代码:
_AFX_THREAD_STATE* pState = AfxGetThreadState();

// for tracking the idle time state
BOOL bIdle = TRUE;
LONG lIdleCount = 0;

// acquire and dispatch messages until a WM_QUIT message is received.
for (;;)
{
   // phase1: check to see if we can do idle work
   while (bIdle &&
    !::PeekMessage(&(pState->m_msgCur), NULL, NULL, NULL, PM_NOREMOVE))
   {
    // call OnIdle while in bIdle state
    if (!OnIdle(lIdleCount++))
     bIdle = FALSE; // assume "no idle" state
   }

   // phase2: pump messages while available
   do
   {
    // pump message, but quit on WM_QUIT
    if (!PumpMessage())
     return ExitInstance();

    // reset "no idle" state after pumping "normal" message
    //if (IsIdleMessage(&m_msgCur))
    if (IsIdleMessage(&(pState->m_msgCur)))
    {
     bIdle = TRUE;
     lIdleCount = 0;
    }

   } while (::PeekMessage(&(pState->m_msgCur), NULL, NULL, NULL, PM_NOREMOVE));
}
Run函数中的for是一个死循环,直到do…while循环中执行ExitInstance为止,这里不讨论这一点。
如果While循环要退出,必须满足两个条件之一:
 PeekMessage在线程的消息循环中检查到了消息,取出,但不会见该消息从消息队列中删除。
 OnIdle返回0值,这意味着没有空闲时间了,程序要做事了。
可见,这两个条件是不相同的,从这两个条件出发,还可以得出如下结论:
 尽管PeekMessage函数没有从线程消息队列中取出任何消息,但是也没有空闲时间了。
 尽管有空闲时间,但PeekMessage从线程消息队列中取到了消息。
这两个解释说明,空闲时间同线程消息队列为空没有必要的联系。
不过,一旦进入do…while循环,执行过PumpMessage函数之后,有一个函数调用IsIdleMessage,用以判断刚分发的那个消息是否可以让程序处于空闲时间。在do…while循环结束之前,如果所有消息都不让程序处于空闲时间,那么函数OnIdle就不能执行,然而只要有一个,OnIdle函数酒可以执行(事实上这样的消息出现频率很大)。但为何要这样设计呢?
最后,受到WM_QUIT消息时调用CWinApp::ExitInstance()做一些清理工作。
2.1.9 PumpMessage
看一下该函数所作的事情:
_AFX_THREAD_STATE *pState = AfxGetThreadState();

if (!::GetMessage(&(pState->m_msgCur), NULL, NULL, NULL))
{
   ::TranslateMessage(&(pState->m_msgCur));
   ::DispatchMessage(&(pState->m_msgCur));
}
调用了GetMessage(通过其它函数),该函数不但从消息队列取消息,之后还将消息删除。然后分配该消息。
2.1.10 AfxWinMain函数InitFailure后的代码
InitFailure之后的代码现在暂不考虑。

2.2 RTTI(运行时识别类)
运行时识类技术主要是在类中添加一个结构变量和一些成员函数,通过对象的指针可以找到对象的类名。
在MFC类库中,将该结构用链表连起来,就构成一个类别型录网,因为结构中含有类名,父类等信息,所以可以遍历链表寻找到本类或父类的信息(至少有名称),以此可以识别类。
2.2.1 CRuntimeClass定义
这里,取未定义_AFXDLL宏。
struct CRuntimeClass
{
// Attributes
LPCSTR m_lpszClassName;
int m_nObjectSize;
UINT m_wSchema; // schema number of the loaded class
CObject* (PASCAL* m_pfnCreateObject)(); // NULL => abstract class
CRuntimeClass* m_pBaseClass;

// Operations
CObject* CreateObject();
BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;

// dynamic name lookup and creation
static CRuntimeClass* PASCAL FromName(LPCSTR lpszClassName);
static CRuntimeClass* PASCAL FromName(LPCWSTR lpszClassName);
static CObject* PASCAL CreateObject(LPCSTR lpszClassName);
static CObject* PASCAL CreateObject(LPCWSTR lpszClassName);

// Implementation
void Store(CArchive& ar) const;
static CRuntimeClass* PASCAL Load(CArchive& ar, UINT* pwSchemaNum);

// CRuntimeClass objects linked together in simple list
CRuntimeClass* m_pNextClass;       // linked list of registered classes
const AFX_CLASSINIT* m_pClassInit;
};
这该结构声明,下面会逐一说明每个成员。
2.2.2 DECLARE_DYNAMIC
这个宏用于在一个类中添加同RTTI相关的成员,下面看这个宏的定义。
#define DECLARE_DYNAMIC(class_name) \
public: \
static const CRuntimeClass class##class_name; \
virtual CRuntimeClass* GetRuntimeClass() const; \

以DECLARE_DYNAMIC(CView) 为例,展开后得到:
class CView{
public:
static const CRuntimeClass classCView;//静态变量
virtual CRuntimeClass* GetRuntimeClass() const;//虚函数声明
… …
};
下面看看宏IMPLEMENT_DYNAMIC的实现。
2.2.3 IMPLEMENT_DYNAMIC
这个宏是对DECLARE_DYNAMIC声明内容的实现,下面是定义:
#define IMPLEMENT_DYNAMIC(class_name, base_class_name) \
IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, NULL, NULL)

#define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew, class_init) \
AFX_COMDAT const CRuntimeClass class_name::class##class_name = { \
   #class_name, sizeof(class class_name), wSchema, pfnNew, \
    RUNTIME_CLASS(base_class_name), NULL, class_init }; \
CRuntimeClass* class_name::GetRuntimeClass() const \
   { return RUNTIME_CLASS(class_name); }

#define RUNTIME_CLASS(class_name) _RUNTIME_CLASS(class_name)
#define _RUNTIME_CLASS(class_name) ((CRuntimeClass*)(&class_name::class##class_name))
以IMPLEMENT_DYNAMIC(CView, CWnd)为例,展开后如下:
AFX_COMDAT const CRuntimeClass CView::classCView = //初始化静态变量
{
"CView",         // m_lpszClassName
sizeof(class CView),       // m_nObjectSize
0xFFFF,         // m_wSchema
NULL,         // m_pfnCreateObject
((CRuntimeClass*)(&CWnd::classCWnd), // m_pBaseClass
NULL,         // m_pNextClass
NULL         // m_pClassInit
};
CRuntimeClass* CView::GetRuntimeClass() const 

return ((CRuntimeClass*)(&CView::classCView);
}
2.2.4 IsKindOf和IsDerivedFrom
该函数定义在CObject类中,看一下它的定义(简化版):
BOOL CObject::IsKindOf(const CRuntimeClass* pClass) const
{
// simple SI case
CRuntimeClass* pClassThis = GetRuntimeClass();
ENSURE(pClassThis);
return pClassThis->IsDerivedFrom(pClass);
}
下面是该函数的一般调用:
pView->IsKindOf(RUNTIME_CLASS(CView));
注意以下参数,该参数展开后如下:
((CRuntimeClass*)(&CView::classCView))
CView::class CView正是CView类的静态变量。
调用:
CRuntimeClass* pClassThis = GetRuntimeClass();
GetRuntimeClass从CObject继承下来的,它返回CView::class CView。
有意思的调用是pClassThis->IsDerivedFrom(pClass);
看看IsDerivedFrom的简化代码:
BOOL CRuntimeClass::IsDerivedFrom(const CRuntimeClass* pBaseClass) const
{
// simple SI case
const CRuntimeClass* pClassThis = this;
while (pClassThis != NULL)
{
   if (pClassThis == pBaseClass)
    return TRUE;
   pClassThis = pClassThis->m_pBaseClass;
}
return FALSE;       // walked to the top, no match
}
很显然,pClassThis就是当前对象所属类的CRuntimeClass静态成员的指针,pBaseClass就是参考类(当前对象是否属于该类)的CRuntimeClass静态成员的指针,通过这两个指针对比(是否相同),来判断对象是否属于参考类的对象。那么为何不通过字符串对比(要知道CRuntimeClass有类的名称字符串)呢?
从while循环可以看出,pClassThis会顺着类型链表向继承类方向遍历,这说明一个对象也属于其继承类类型,而这一点是无法通过类名称字符串比较做到的。
2.3 (Dynamic Create)动态创建
尽管能够在运行时得到一个类的名称,但还是无法通过该名称动态创建类的对象,必须再向其它办法。为此,就要利用CRuntimeClass的m_pfnCreateObject成员,下面是该成员的定义(参考RTTI):
CObject* (PASCAL* m_pfnCreateObject)();
可见,这是一个函数指针,它返回CObject*。
如果想一个类具有动态创建对象的功能,只需要实现一个函数,让该函数创建对象,并且让m_pfnCreateObject指向该函数即可。
DECLARE_DYNCREATE和IMPLEMENT_DYNCREATE宏就是用来做这件事情的。
2.3.1 DECLARE_DYNCREATE
看一下该宏的定义:
#define DECLARE_DYNCREATE(class_name) \
DECLARE_DYNAMIC(class_name) \
static CObject* PASCAL CreateObject();
DECLARE_DYNAMIC参考RTTI部分。
可见,该宏也就是为类添加一个静态成员CreateObject();
如DECLARE_DYNCREATE(CWnd)展开后如下:
class CWnd{
public:
static const CRuntimeClass classCView;//静态变量
virtual CRuntimeClass* GetRuntimeClass() const;//虚函数声明
static CObject* PASCAL CreateObject();//静态成员函数
… …
};
2.3.2 IMPLEMENT_DYNCREATE
看一下该宏的定义:
#define IMPLEMENT_DYNCREATE(class_name, base_class_name) \
CObject* PASCAL class_name::CreateObject() \
   { return new class_name; } \
IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, \
   class_name::CreateObject, NULL)
IMPLEMENT_RUNTIMECLASS参考RTTI的DECLARE_DYNAMIC。
如IMPLEMENT_DYNCREATE(CWnd, CCmdTarget)展开后如下:
AFX_COMDAT const CRuntimeClass CWnd::classCWnd = //初始化静态变量
{
"CWnd",         // m_lpszClassName
sizeof(class CWnd),       // m_nObjectSize
0xFFFF,         // m_wSchema
CWnd::CreateObject,      // m_pfnCreateObject
((CRuntimeClass*)(&CWnd::classCWnd), // m_pBaseClass
NULL,         // m_pNextClass
NULL         // m_pClassInit
};
CRuntimeClass* CWnd::GetRuntimeClass() const 

return ((CRuntimeClass*)(&CWnd::classCWnd);
}
CObject* PASCAL CWnd::CreateObject() { return new CWnd;}
从这个宏也可以看出,拥有动态创建能力的类也一定有动态识别能力。
下面再看一下CRuntimeClass的实现(简化):
CObject* CRuntimeClass::CreateObject()
{
if (m_pfnCreateObject == NULL)
   return NULL;
CObject* pObject = NULL;
TRY
{
   pObject = (*m_pfnCreateObject)();
}
END_TRY
return pObject;
}
所以,只要能够找到一个类的CRuntimeClass静态成员,就可以动态创建该类的对象,当然,要找到该成员是不费吹灰之力的。
2.3.3 使用
例如动态创建一窗口对象:
CRuntimeClass* prc = RUNTIME_CLASS(CWnd);
CWnd* pWnd = (CWnd*)prc->CreateObject();
BOOL b = pWnd->IsKindOf(RUNTIME_CLASS(CWnd));
delete pWnd;
2.4 Persistence(永久保存机制)
暂时不看。
2.5 Serialize(数据读写)
暂时不看。
2.6 Message Mapping(消息映射)
对于同消息处理有关的类,MFC为其建立一个消息映射表,当有消息传入时,通过查找消息映射表就可以找到对应的函数来处理。
消息映射表其实就是类的一个消息处理成员,如果它的基类也同消息有关,则这个成员的某个子段指向基类的,???
2.6.1 DECLARE_MESSAGE_MAP
这是一个宏,于消息有关的类都有这个宏,下面是该宏的定义:
#define DECLARE_MESSAGE_MAP() \
protected: \
static const AFX_MSGMAP* PASCAL GetThisMessageMap(); \
virtual const AFX_MSGMAP* GetMessageMap() const; \
例如在CView类中展开该宏,效果如下:
class CView : public CWnd
{
… …
//DECLARE_MESSAGE_MAP()
static const AFX_MSGMAP* PASCAL GetThisMessageMap(); 
virtual const AFX_MSGMAP* GetMessageMap() const; 
}
可以看出,该宏实际上为CView类添加了两个函数,一个是静态函数,另一个是虚函数。
2.6.2 BEGIN…ON…END宏
在定义类的成员时,也要对DECLARE_MESSAGE_MAP()添加的函数进行实现,这两个宏就起这个作用,下面是这两个宏的定义:
#define BEGIN_MESSAGE_MAP(theClass, baseClass) \
const AFX_MSGMAP* theClass::GetMessageMap() const \
   { return GetThisMessageMap(); } \
const AFX_MSGMAP* PASCAL theClass::GetThisMessageMap() \
{ \
   typedef theClass ThisClass;         \
   typedef baseClass TheBaseClass;        \
   static const AFX_MSGMAP_ENTRY _messageEntries[] = \
   {

#define END_MESSAGE_MAP() \
   {0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } \
}; \
   static const AFX_MSGMAP messageMap = \
   { &TheBaseClass::GetThisMessageMap, &_messageEntries[0] }; \
   return &messageMap; \
}
可以看出,第一个参数theClass就是当前类的名称,第二个参数baseClass可能是基类的名称,但不一定(例如CWinApp)。
同样还是以CView为例,看一下这两个宏的使用:
BEGIN_MESSAGE_MAP(CView, CWnd)
ON_WM_PAINT()
… …

// Standard commands for split pane
ON_COMMAND_EX(ID_WINDOW_SPLIT, &CView::OnSplitCmd)
… …
END_MESSAGE_MAP()
省略号部分代表还有其他内容,为了简单这里仅写3个。
展开后的结果如下:
const AFX_MSGMAP* CView::GetMessageMap() const

return GetThisMessageMap(); 
}
const AFX_MSGMAP* PASCAL CView::GetThisMessageMap()
{
typedef CView ThisClass;
typedef CWnd TheBaseClass;
static const AFX_MSGMAP_ENTRY _messageEntries[] =
{
   { 
WM_PAINT, 
0,
0, 
0, 
AfxSig_vv, 
(AFX_PMSG)(…)( &CView::OnPaint)) 
}, //ON_WM_PAINT
   … …
   { 
WM_COMMAND, 
CN_COMMAND, 
(WORD)ID_WINDOW_SPLIT, 
(WORD)ID_WINDOW_SPLIT,
AfxSigCmd_EX,
(AFX_PMSG)(…)(&CView::OnSplitCmd)) 
},// ON_COMMAND_EX
   … …
   {0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } //END_MESSAGE_MAP()
};

static const AFX_MSGMAP messageMap =

   &TheBaseClass::GetThisMessageMap, &_messageEntries[0]
};
return &messageMap;

看一下函数:GetThisMessageMap
它在内部创建一个局部静态数据结构数组_messageEntries,这说明调用过该函数该数组才会被初始化。而这两个宏之间的部分就是用来初始化该结构数组变量的数据。
所以,从GetMessageMap()可以看出,它返回的实际是一个局部静态结构数组的指针。
下面详细分析一下该函数GetThisMessageMap。
2.6.3 GetThisMessageMap
_messageEntries是AFX_MSGMAP_ENTRY结构数组,它实际就是消息映射表,记录每一个消息ID(第一个参数)到消息处理函数指针(最后一个参数,)的映射,当然还有其它一些信息,例如消息来自于哪个控件(该控件ID)等等,这个消息结构的其它成员以后再学习。
实际上,_messageEntries记录的都是大部分都是当前类能够处理的消息映射表,宏BEGIN_MESSAGE_MAP(theClass, baseClass)的第一个参数正是用在这个地方,指出能够处理消息的函数所属的类。
messageMap是一个结构变量,它的成员很有意思,第一个成员是一个函数指针,它指向基类(也可能是其它类)的GetThisMessageMap函数指针;上文提到的宏BEGIN_MESSAGE_MAP(theClass, baseClass)的第二个参数正是用在这个地方。
另一个成员指向_messageEntries,也就是消息映射表。
很显然,通过该函数可以很容易找到相应的消息处理函数,即使当前类不能处理某,还可以在基类中(或指定地类中)寻找。
下面举几个消息映射的例子。
2.6.4 CCmdTarget的消息映射
看一下这个类消息映射表的定义:
const AFX_MSGMAP* CCmdTarget::GetMessageMap() const
{
return GetThisMessageMap();
}

const AFX_MSGMAP* CCmdTarget::GetThisMessageMap()
{
static const AFX_MSGMAP_ENTRY _messageEntries[] =
{
   { 0, 0, AfxSig_end, 0 }     // nothing here
};
static const AFX_MSGMAP messageMap =
{
   NULL,
   &_messageEntries[0]
};
return &messageMap; 
}
该类没有BEGAIN…ON…END宏,看一下消息映射表_messageEntries,它只有一个元素{ 0, 0, AfxSig_end, 0 },显然,该元素不会处理任何消息。
再看看messageMap,第一个成员为NULL,也就是说,如果一个消息达这里还没有被处理,那么这个消息再也不会被处理了。
2.6.5 CView的消息映射
先看一下CView类(这里仅写出部分代码):
class AFX_NOVTABLE CView : public CWnd
{
...
afx_msg void OnPaint();
afx_msg BOOL OnSplitCmd(UINT nID);
DECLARE_MESSAGE_MAP()
};
BEGIN_MESSAGE_MAP(CView, CWnd)
ON_WM_PAINT()
ON_COMMAND_EX(ID_WINDOW_SPLIT, &CView::OnSplitCmd)
END_MESSAGE_MAP()
展开这部分代码后如下:
class AFX_NOVTABLE CView : public CWnd
{
...
afx_msg void OnPaint();
afx_msg BOOL OnSplitCmd(UINT nID);
static const AFX_MSGMAP* PASCAL GetThisMessageMap(); 
virtual const AFX_MSGMAP* GetMessageMap() const;
};
const AFX_MSGMAP* CCmdTarget::GetMessageMap() const
{
return GetThisMessageMap();
}
const AFX_MSGMAP* CCmdTarget::GetThisMessageMap()
{
static const AFX_MSGMAP_ENTRY _messageEntries[] =
{
   { WM_PAINT, 0, 0, 0, AfxSig_vv, (…)( &ThisClass :: OnPaint)) },//ON_WM_PAINT
   { WM_COMMAND, CN_COMMAND, (WORD) ID_WINDOW_SPLIT, 
(WORD) ID_WINDOW_SPLIT, AfxSigCmd_EX,(...)&CView::OnSplitCmd)) },
   { 0, 0, AfxSig_end, 0 }     // nothing here
};
static const AFX_MSGMAP messageMap =
{
   &CWnd::GetThisMessageMap, &_messageEntries[0]
};
return &messageMap;
}
void CView::OnPaint(){…}
BOOL CView:: OnSplitCmd(UINT nID);{…}
…表示一种强制类型转换,这里暂不考虑它。
看一下粗体部分字体,OnPaint和OnSplitCmd是必须定义的。
这也说明,消息WM_PAINT映射倒CView::OnPaint函数;再看一下另一个函数OnSplitCmd,它可以处理消息WM_COMMAND,但它还有两个参数,详情可以参看msdn,注意宏ON_COMMAND_EX展开后的代码,这说明如果有一个WM_COMMAND消息,且它的第一个参数是CN_COMMAND,它第二个参数是ID_WINDOW_SPLIT时,才能被OnSplitCmd处理。
所以,以上说明不同的消息,它们的宏定义多少也有区别,本质上,也就是对消息映射表_messageEntries的各个元素初始化也是不同的。所以消息映射表对应的结构体AFX_MSGMAP_ENTRY各个成员正式反映了消息的不同类型,有些消息需要使用较多的成员,但有些消息使用很少的成员。
CWnd是CView的基类,它也是BEGIN_MESSAGE_MAP的第二个参数。
2.6.6 消息的分派
当窗口产生一个消息后,它从哪里开始进入消息映射表中呢?
MFC提供了一个全局函数AfxRegisterWndClass,暂时不关心该函数是如何调用的,但可以肯定一点,当有窗口创建时,会调用该函数,看一下该函数体的部分代码:
LPCTSTR AFXAPI AfxRegisterWndClass(…)
{
WNDCLASS wndcls;
… …
wndcls.lpfnWndProc = DefWindowProc;
… …
}
显然,这个函数的作用是注册一个窗口类WNDCLASS (如果窗口类不存在),其中,成员lpfnWndProc是一个函数指针,它指向一个消息处理函数,在窗口消息循环中(CWinApp::Run函数)中调用(可能是间接)DispatchMessage函数,该函数的作用是将消息传给lpfnWndProc所指向的函数,这就构成了基本的窗口处理过程。
然而,MFC还不仅这么简单,看一下面几个函数(部分代码):
BOOL CWnd::CreateEx(...)
{
… …
AfxHookWindowCreate(this);
… …
}
void AFXAPI AfxHookWindowCreate(CWnd* pWnd)
{

pThreadState->m_hHookOldCbtFilter = ::SetWindowsHookEx(WH_CBT,
    _AfxCbtFilterHook, NULL, ::GetCurrentThreadId());

}
CWnd创建窗口时安装了一个消息挂钩,这个挂钩的类型是WH_CBT,关于这种类型挂钩详细类型参看msd,绝大部分的windows消息(事实上我没有遇到过有哪个消息例外)都能被该挂钩函数过滤,而且,在windows通过正常方法处理消息之前,都会先调用挂钩函数。
下面再看一下挂钩函数_AfxCbtFilterHook:
_AfxCbtFilterHook(int code, WPARAM wParam, LPARAM lParam)
{
… …
if (code != HCBT_CREATEWND)
{
   // wait for HCBT_CREATEWND just pass others on...
   return CallNextHookEx(pThreadState->m_hHookOldCbtFilter, code,
    wParam, lParam);
}
… …
WNDPROC afxWndProc = AfxGetAfxWndProc();
oldWndProc = (WNDPROC)SetWindowLongPtr(hWnd, GWLP_WNDPROC,
(DWORD_PTR)afxWndProc);
… …
}
WNDPROC AFXAPI AfxGetAfxWndProc()
{
… …
return &AfxWndProc;
}
这里,又将消息处理函数换成AfxWndProc。至此,可以清楚的知道,::DispatchMessage最终会将窗口消息传给AfxWndProc。
2.6.7 消息的传递
先看看消息的起头函数:
LRESULT CALLBACK AfxWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
// all other messages route through message map
CWnd* pWnd = CWnd::FromHandlePermanent(hWnd);
… …
if (pWnd == NULL || pWnd->m_hWnd != hWnd)
   return ::DefWindowProc(hWnd, nMsg, wParam, lParam);
return AfxCallWndProc(pWnd, hWnd, nMsg, wParam, lParam);
}
LRESULT AFXAPI AfxCallWndProc(…)
{

lResult = pWnd->WindowProc(nMsg, wParam, lParam);

return lResult;
}
在MFC中,很多窗口类都有成员函数WindowProc(包括继承的),大部分都是从CWnd派生来的,看一下下面几个函数:
LRESULT CWnd::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
// OnWndMsg does most of the work, except for DefWindowProc call
LRESULT lResult = 0;
if (!OnWndMsg(message, wParam, lParam, &lResult))
   lResult = DefWindowProc(message, wParam, lParam);
return lResult;
}
LRESULT CWnd::DefWindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
{
if (m_pfnSuper != NULL)
   return ::CallWindowProc(m_pfnSuper, m_hWnd, nMsg, wParam, lParam);

WNDPROC pfnWndProc;
if ((pfnWndProc = *GetSuperWndProcAddr()) == NULL)
   return ::DefWindowProc(m_hWnd, nMsg, wParam, lParam);
else
   return ::CallWindowProc(pfnWndProc, m_hWnd, nMsg, wParam, lParam);
}
如果OnWndMsg执行失败,调用DefWindowProc,OnWndMsg函数做了哪些事情呢?
BOOL CWnd::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{

if (message == WM_COMMAND){…(OnCommand(wParam, lParam);…}
if (message == WM_NOTIFY) {…(OnNotify(wParam, lParam);…}
if (message == WM_ACTIVATE) _AfxHandleActivate(…);
if (message == WM_SETCURSOR) _AfxHandleSetCursor(…);
… …
}
从OnWndMsg可以看出,对于不同类型的消息,调用的处理函数也有不同。

… …
for (/* pMessageMap already init'ed */; pMessageMap->pfnGetBaseMap != NULL;
    pMessageMap = (*pMessageMap->pfnGetBaseMap)())
{
   if (message < 0xC000)
{
… …
    AfxFindMessageEntry(pMessageMap->lpEntries, message, 0, 0)
    … …
}
   else
   {
    lpEntry = pMessageMap->lpEntries;
    while(lpEntry = AfxFindMessageEntry(lpEntry, 0xC000, 0, 0)) != NULL)
    {
     … … 
}
}
}
… …














本文转自jetyi51CTO博客,原文链接: http://blog.51cto.com/jetyi/294422,如需转载请自行联系原作者





相关文章
|
存储 API 数据库
【MFC】MFC基础篇(1)
【MFC】MFC基础篇(1)
【MFC】MFC基础篇(1)
|
IDE 开发工具 C语言
|
存储 索引
|
API 编译器 Linux
(七):处理MFC
版权声明:您好,转载请留下本人博客的地址,谢谢 https://blog.csdn.net/hongbochen1223/article/details/50703886 (一):简介 为了能够在一个Winelib应用中使用MFC,你需要首先使用Winelib重新编译MFC。
1213 0
|
安全 容器 开发者
用MFC实现WebGUI--(CDHtmlDialog)
自从去年年底一次棘手的界面,开始研究用web做界面到现在大约1年,这一年间不是局限在实现层面,也并非一直研究这一个问题,有很多问题其实不是问题,只是自己没有想清楚或者思想没放开。对于一个界面开发人员,想必拉的对话框不少于100个,腻味不必说,光是对话框大小改变导致控件跟着变化都需要一番功夫,加上界面美观,界面的风格统一,界面的灵活多变......,头痛。
1401 0
SonicUI在MFC中的使用
SonicUI是一个GUI引擎,提供了一些简单的UI组件实现高效率的UI效果,例如:自绘按钮、异形窗体、动画、超链接和图像操作方法。此项目作者开源到CodeProject,地址为:http://www.codeproject.com/KB/GDI/SonicUI.aspx。
1181 0
|
C++ Windows
vs2010 mfc
引用:http://blog.sina.com.cn/s/blog_6c617ee301010vgr.html 1.添加消息处理函数:  右击项目名称-》类向导-》选择相应类名(我这是CfirstmfcView)-》选中消息(WM_OnMouseMove)-》默认生成函数OnMouseMove()-》选应用。
1031 0
|
Windows C++
vs mfc
引用:http://zhidao.baidu.com/question/90768814.html Win32 Application: 文件-新建-项目-win32-选择控制台应用程序或win32项目-确定-完成MFC WINDOWS程序: 文件-新建-项目-MFC-MFC应用程序-确定-完成。
607 0