01：MFC应用程序编程

一 MFC的发展

VC 1.0->VC 5.0->VC 6.0->VC2008 SP1)->VS2010

二 MFC基础

1 MFC 微软基础类库

采用类的方式,将Win32 API等进行封装,形成的库.

2 MFC相关的头文件

afx.h   (application framework, X)

afxwin.h  (类似于windows.h)

afxext.h  (MFC扩展头文件)

...

三 MFC应用程序

MFC应用程序主要分为以下三类，对比通常的应用程序，变化的地方如下：

1 MFC的控制台程序

1.1 包含afx系列的头文件

1.2 CWinApp theApp - MFC的应用程序类，封装了应用程序的启动过程.

1.3 AfxWinInit MFC初始化函数，将应用程序的信息初始化.

2 MFC的动态库和静态库

2.1 静态库 2.1.1 增加了MFC的支持

2.2 动态库 动态库分类如下： 2.2.1 MFC规则DLL分为如下两类： 使用MFC静态库的规则DLL 使用MFC动态库的规则DLL 2.2.2 MFC扩展DLL 动态库与C++动态库的不同点如下： 1 增加了MFC相关的afx头文件 2 包含一个继承CWinApp类, 并且声明了该类的全局变量.

3 MFC应用程序

3.1 单文档视图应用程序 3.1.1 包含一个继承CWinApp类 3.1.2 CMainFrame类 3.1.3 CView的一个子类 3.1.4 CDocument的一个子类

3.2 多文档视图应用程序 3.2.1 包含一个继承CWinApp类 3.2.2 CMainFrame类 3.2.3 CView的一个子类 3.2.4 CDocument的一个子类 3.2.5 CChildFrame 子框架窗口

3.3 对话框应用程序 3.3.1 包含一个继承CWinApp类 3.3.2 对话框类

四 MFC中的类

在MSDN中搜索“Hierarchy chart”就可以看到整个MFC类继承图的关系

常用的类分类如下：

1 CObject类

MFC类的基础,大部分MFC类都是它的子类。

CObject封装了MFC的基础的机制，比如：

1.1 new和Delete

1.2 Assert

1.3 运行式信息

1.4 动态创建

1.5 序列化

2 应用程序框架类

封装了应用程序启动相关信息，以及MFC消息映射机制。

3 窗口支持类

封装了窗口操作的API,各种控件及窗口的框架.

4 绘图类

提供了绘图API的封装,以及相关的GDI设备封装.

5 MFC的集合类

提供了数组、链表、映射的数据结构的操作.

6 数据库支持类

ODBC支持类和DAO的支持类。DAO的类已作废.

7 同步类

临界区/事件/互斥/信号量的封装

8 Socket类

封装了socket的编程.

9 常用数据结构

CString CRect CPoint等.

五第一个MFC程序

不使用向导，自己创建一个MFC应用程序。

1.新建一个Win32 Application项目“WinMFC”

2.选择一个简单的Win32应用程序

3.修改环境为MFC应用程序的环境 3.1修改stdafx.h头文件，将#include <Windows.h> 改成#include <afxwin.h> 3.2删掉WinMFC.cpp文件中的WinMain()函数 3.3进入项目的属性设置

4.增加应用程序类CWinApp 4.1在WinMFC.cpp文件中编写继承自CWinApp类的类CMyApp类 4.2在CMyApp类中添加InitInstance函数 InitInstance函数是在程序启动过程中,会被调用,我们可以在这个函数中,创建窗口或者各种初始化操作. 4.3添加CMyApp的全局变量 //应用程序类 class CMyApp : public CWinApp { public: virtual BOOL InitInstance( ); }; //定义CMyApp的全局变量 CMyApp theApp; //初始化函数 BOOL CMyApp::InitInstance( ) { AfxMessageBox("Hello App"); return TRUE; }

这样，一个基本的MFC应用程序就创建好了。编译运行，会看到如下结果：

这个MFC是怎么执行起来的呢？？先别急

程序可以启动了，下面开始创建窗口

1.在WinMFC.cpp文件中编写继承自CFrameWnd类的类CMyFrameWnd类

2.在App的InitInstance函数定义窗口对象

3.创建窗口(Create)并显示(ShowWindow)

4.将窗口设置成App的主窗口m_pMainWnd = pWnd;

5.在CMyFrameWnd中添加窗口处理函数WindowProc,在WindowProc中处理消息

WinMFC.cpp完整代码

// WinMFC.cpp : Defines the entry point for the application. // #include "stdafx.h" //框架窗口类 class CMyFrameWnd : public CFrameWnd { public: //窗口处理函数 virtual LRESULT WindowProc( UINT message, WPARAM wParam, LPARAM lParam ); }; //窗口处理函数 LRESULT CMyFrameWnd::WindowProc( UINT message, WPARAM wParam, LPARAM lParam ) { switch( message ) { case WM_CREATE: AfxMessageBox( "WM_CREATE" ); break; case WM_PAINT: { PAINTSTRUCT ps = { 0 }; HDC hDC = ::BeginPaint( m_hWnd,  &ps ); CHAR szText[] = "Hello world!"; TextOut( hDC, 100, 100, szText, strlen( szText ) ); ::EndPaint( m_hWnd, &ps ); } break; } return CFrameWnd::WindowProc( message, wParam, lParam ); } //应用程序类 class CMyApp : public CWinApp { public: virtual BOOL InitInstance( ); }; //定义CMyApp的全局变量 CMyApp theApp; //初始化函数 BOOL CMyApp::InitInstance( ) { //定义窗口对象 CMyFrameWnd * pWnd = new CMyFrameWnd(); //创建窗口 pWnd->Create( NULL, "MyApp" ); //显示窗口 pWnd->ShowWindow( SW_SHOW ); //设置主窗口 m_pMainWnd = pWnd; return TRUE; }

六 MFC应用程序的启动

MFC应用程序与Win32程序一样,都需要程序的入口函数.

1 CWinApp

应用程序类,封装了应用程序的相关信息,可以提供初始化 消息循环等处理. CWinApp的构造函数中执行了什么: 1 将this指针保存到ThreadState中.this指针就是CMyApp对象----theApp pThreadState->m_pCurrentWinThread = this 2 将this指针保存到ModuleState中 pModuleState->m_pCurrentWinApp = this 3 各种的成员变量的初始化

2 程序的入口函数

在CMyApp::InitInstance()函数中加一个断点，然后运行，程序在断点处停下来。 这时候打开“Call Stack”窗口，观察程序的调用过程。 PS:双击调用栈里面的函数，就会跳过去~~

根据跟踪调用过程，得到如下结论： 1 MFC也拥有WinMain函数,与Win32程序一致. 2 在WinMain函数中,调用了AfxWinMain函数. AfxWinMain函数中执行了什么： 1 调用AfxWinInit初始化应用程序 2 调用CWinApp的InitApplication初始MFC内部数据 3 调用CWinThread的InitInstance函数做初始化操作 4 调用CWinThread的Run函数进行消息循环 5 调用AfxWinTerm函数做退出处理. 3 现在，再来总结一下程序的启动过程： 1 CWinApp在构造过程中, 将自己的this指针分别保存到全局变量中. 2 在AfxWinMain执行中,首先从全局变量中将保存CWinApp的地址获取到. 3 调用CWinApp的InitInstance函数,进行初始化.我们在InitInstance函数中,创建窗口等初始化操作. 4 调用Run函数,进行消息循环.

七窗口创建及窗口处理函数

1 窗口创建过程

1 窗口的参数初始化,包括窗口类，窗口风格，窗口处理函数等信息. 注意:将DefWindowProc注册成窗口处理函数.

2 设置 "创建HOOK" (钩子) 当窗口创建的时候,调用这个HOOK函数. Wnd -> HOOK -> WndProc

3 创建窗口 CreateWindowEx

4 卸载 "创建HOOK" 将HOOK程序从当前程序中移除

2 HOOK(钩子)程序

上面说的"创建HOOK"到底做了什么:

1 使用AfxGetAfxWndProc函数获取了一个WNDPROC函数指针, 也就是AfxWndProc(AfxWndProcBase)函数地址.

2 将这个WNDPROC函数设置成当前窗口的处理函数

3 将窗口句柄和窗口类的指针保存到MFC的映射数据中(afxMapHWND函数)。这样就可以通过窗口句柄获取对应的窗口对象指针了。

总得来说,就是在窗口创建时,将AfxWndProc函数设置为当前窗口的窗口过程函数。

3 AfxWndProc(Base)窗口处理函数

AfxGetAfxWndProc函数到底做了什么：

1 根据窗口句柄获取了相对应的窗口的CWnd *类型的指针,从映射数据中根据窗口句柄查找CWnd *指针.(afxMapHWND函数)

2 调用AfxCallWndProc函数

3 在AfxCallWndProc函数中,调用CWnd的WindowProc函数 注意: 在MFC程序当中,所有窗口处理都是使用一个函数（AfxWndProc函数）.

4 窗口的创建及处理过程

经过上面的分析，总结窗口的创建及处理过程如下：

1 将DefWindowProc函数注册成当前窗口的处理函数

2 设置钩子函数

3 创建窗口,并执行钩子函数

4 在钩子函数中将窗口类指针和窗口句柄的对应关系保存.

5 在钩子函数中将AfxWndProc(Base)函数设置当前窗口的窗口处理函数

6 在AfxWndProc(Base)收到窗口消息,从窗口对应关系中,查询相应的窗口类指针.

7 调用窗口类WindowProc函数处理消息

八消息映射

为了简化Win32的API编程中复杂的switch...case...，MFC重新封装了消息的传递方式。

下面，新建一个Win32应用程序，通过修改它实现MFC的消息映射，来观察一下。（PS：其实创建过程跟上面的过程差不多，多写几遍，写到吐为止）

1.修改stdafx.h头文件，将#include <Windows.h> 改成#include <afxwin.h>

2.

3.删掉MFCMsg.cpp文件中的WinMain()函数

4. MFCMsg.cpp中定义CMsgFrame、CMsgApp和theApp class CMsgFrame : public CFrameWnd { public: virtual LRESULT WindowProc( UINT nMsg, WPARAM wParam, LPARAM lParam); }; LRESULT CMsgFrame::WindowProc( UINT nMsg, WPARAM wParam, LPARAM lParam) { //以前这里就是很多switch来处理，现在没了 //被后面的BEGIN_MESSAGE_MAP()到END_MESSAGE_MAP中间的内容取代了 return CFrameWnd::WindowProc( nMsg, wParam, lParam ); } class CMsgApp : public CWinApp { public: virtual BOOL InitInstance( ); }; CMsgApp theApp; BOOL CMsgApp::InitInstance( ) { CMsgFrame * pWnd = new CMsgFrame( ); pWnd->Create( NULL, "MsgApp" ); m_pMainWnd = pWnd; m_pMainWnd->ShowWindow( SW_SHOW ); m_pMainWnd->UpdateWindow( ); return TRUE; }

5.下面是跟前面不同的地方了。 在CMsgFrame中增加消息映射的宏 class CMsgFrame : public CFrameWnd { public: virtual LRESULT WindowProc( UINT nMsg, WPARAM wParam, LPARAM lParam); public: //消息映射宏定义 DECLARE_MESSAGE_MAP( ) }; //消息映射的宏实现 BEGIN_MESSAGE_MAP( CMsgFrame, CFrameWnd ) END_MESSAGE_MAP( )

6.增加一个OnPaint函数作为WM_PAINT消息的响应函数，并在BEGIN_MESSAGE_MAP和END_MESSAGE_MAP之间添加消息映射 class CMsgFrame : public CFrameWnd { public: virtual LRESULT WindowProc( UINT nMsg, WPARAM wParam, LPARAM lParam); public: //消息映射宏定义 DECLARE_MESSAGE_MAP( ) public: //消息函数 afx_msg LRESULT OnPaint( WPARAM wParam,LPARAM lParam ); }; //消息映射的宏实现 BEGIN_MESSAGE_MAP( CMsgFrame, CFrameWnd ) //消息和消息处理函数的对应 ON_MESSAGE( WM_PAINT, OnPaint ) END_MESSAGE_MAP( ) LRESULT CMsgFrame::OnPaint( WPARAM wParam, LPARAM lParam ) { PAINTSTRUCT ps = { 0 }; HDC hDC = ::BeginPaint( m_hWnd, &ps ); TextOut( hDC, 100, 100, "Msg", 3 ); ::EndPaint( m_hWnd, &ps ); return 0; }

此时的运行结果：

7.同理，添加一个WM_CREATE消息： class CMsgFrame : public CFrameWnd { public: virtual LRESULT WindowProc( UINT nMsg, WPARAM wParam, LPARAM lParam); public: //消息映射宏定义 DECLARE_MESSAGE_MAP( ) public: //消息函数 afx_msg LRESULT OnPaint( WPARAM wParam, LPARAM lParam ); afx_msg LRESULT OnCreate( WPARAM wParam, LPARAM lParam ); }; //消息映射的宏实现 BEGIN_MESSAGE_MAP( CMsgFrame, CFrameWnd ) //消息和消息处理函数的对应 ON_MESSAGE( WM_PAINT, OnPaint ) ON_MESSAGE( WM_CREATE, OnCreate ) END_MESSAGE_MAP( ) LRESULT CMsgFrame::OnCreate( WPARAM wParam, LPARAM lParam ) { AfxMessageBox("OnCreate"); return 0; } LRESULT CMsgFrame::OnPaint( WPARAM wParam, LPARAM lParam ) { PAINTSTRUCT ps = { 0 }; HDC hDC = ::BeginPaint( m_hWnd, &ps ); TextOut( hDC, 100, 100, "Msg", 3 ); ::EndPaint( m_hWnd, &ps ); return 0; }

经过以上的分析，总结消息映射如下：

1 消息映射添加步骤

1 在FrameWnd添加消息宏定义 DECLARE_MESSAGE_MAP

2 添加消息宏实现

3 添加消息处理函数

4 添加消息和处理函数的对应

2 消息宏的实现

DECLARE_MESSAGE_MAP等到底是什么呢？将这些宏展开如下：

//消息映射宏DECLARE_MESSAGE_MAP展开 private: static const AFX_MSGMAP_ENTRY _messageEntries[]; protected: static AFX_DATA const AFX_MSGMAP messageMap; static const AFX_MSGMAP* PASCAL _GetBaseMessageMap(); virtual const AFX_MSGMAP* GetMessageMap() const;

//BEGIN_MESSAGE_MAP( CMsgFrame, CFrameWnd )展开 const AFX_MSGMAP* PASCAL CMsgFrame::_GetBaseMessageMap() { return &CFrameWnd::messageMap; } const AFX_MSGMAP* CMsgFrame::GetMessageMap() const { return &CMsgFrame::messageMap; } AFX_COMDAT AFX_DATADEF const AFX_MSGMAP CMsgFrame::messageMap = { &CMsgFrame::_GetBaseMessageMap, &CMsgFrame::_messageEntries[0] }; AFX_COMDAT const AFX_MSGMAP_ENTRY CMsgFrame::_messageEntries[] = {

//ON_MESSAGE( WM_PAINT, OnPaint )展开 { WM_PAINT, 0, 0, 0, AfxSig_lwl,(AFX_PMSG)(AFX_PMSGW)(LRESULT (AFX_MSG_CALL CWnd::*)(WPARAM, LPARAM))&OnPaint },

//END_MESSAGE_MAP()展开 {0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } };

先不要晕，将展开的代码多看几遍，分析一下就清楚了。

其中有些数据类型需要解释一下：

1 AFX_MSGMAP_ENTRY 是用于保存消息ID与对应函数指针,及相关的信息 struct AFX_MSGMAP_ENTRY{ UINT nMessage; //消息ID UINT nCode;//通知代码 UINT nID; //控件的ID UINT nLastID;//控件的ID范围的最后 UINT nSig;//操作类型或pfn函数类型 AFX_PMSG pfn;//消息处理函数的函数指针 };

2 AFX_MSGMAP 用于保存GetBaseMap的函数地址及AFX_MSGMAP_ENTRY数组的地址. struct AFX_MSGMAP{ //函数指针 const AFX_MSGMAP* (PASCAL* pfnGetBaseMap)(); //AFX_MSGMAP_ENTRY类型指针 const AFX_MSGMAP_ENTRY* lpEntries; };

下面对上面的宏代码做一些说明

1 _messageEntries[]， 静态成员，类型为 AFX_MSGMAP_ENTRY。 保存CMsgFrame中消息ID和对应的消息处理函数的数组。

2 messageMap， 静态成员，类型为 AFX_MSGMAP。 保存了CMsgFrame中的_GetBaseMessageMap函数指针以及_messageEntries数组地址

3 _GetBaseMessageMap， 静态成员 获取父类的messageMap的地址

4 GetMessageMap，虚函数 获取自己的messageMap地址

下面通过“->”来捋一下几个成员直接的关系：

CMsgFrame::GetMessageMap -〉&messageMap{ &_messageEntries[0] -> { ID<->Func, ID<->Func, .... } _GetBaseMessageMap -> &parent::messageMap { &_messageEntries[0], _GetBaseMessageMap->&parent::messageMap } }

3 消息映射过程

1 消息处理函数WindowProc收到消息后,调用OnWndMsg处理消息,OnWndMsg如果不处理消息,那么WindowProc将调用DefWindowProc默认处理消息并返回.

2 OnWndMsg处理消息 1 使用GetMessageMap函数获取该窗口类的messageMap变量的地址. const AFX_MSGMAP* pMessageMap; pMessageMap = GetMessageMap(); 2 在messageMap中的lpEntries数组中,查找消息ID所对应的数组元素. 3 如果未找到,获取父类的messageMap指针,返回3.2.2,从父类的lpEntries数组继续查找. 4 如果找到,获取找到的数组元素的地址lpEntry,退出查找过程,执行下一步. const AFX_MSGMAP_ENTRY* lpEntry = NULL; for ( ;  pMessageMap != NULL; pMessageMap = (*pMessageMap->pfnGetBaseMap)()) { lpEntry = AfxFindMessageEntry( pMessageMap->lpEntries, message, 0, 0)) if( lpEntry != NULL ) { goto LDispatch; } } 5 根据找到的lpEntry的nSig标识,调用lpEntry当中的pfn函数指针,处理消息. LDispatch: union MessageMapFunctions mmf; mmf.pfn = lpEntry->pfn; int nSig; nSig = lpEntry->nSig; switch (nSig) { case AfxSig_lwl: lResult = (this->*mmf.pfn_lwl)(wParam, lParam); break; }

九MFC的消息分类

MFC的消息分类按照处理方式来分。主要分为4类：

1 窗口消息

例如WM_CREATE、WM_PAINT、鼠标、键盘等消息,这些消息的处理方式是直接调用消息处理函数.

这类消息使用的宏：

ON_MESSAGE(  )

ON_WM_XXXXX( ): ON_WM_CREATE()

消息处理时,采用上面的处理方式.

前面的WM_CREATE消息就不用写成ON_MESSAGE( WM_CREATE, OnCreate ),而直接写成ON_WM_CREATE即可。

函数的定义和声明也要相应地修改为：

afx_msg LRESULT OnCreate( WPARAM wParam, LPARAM lParam );	afx_msg int OnCreate();
LRESULT CMsgFrame::OnCreate( WPARAM wParam, LPARAM lParam ) { AfxMessageBox("OnCreate"); return 0; }	int CMsgFrame::OnCreate() { AfxMessageBox("OnCreate"); return 0; }

2 命令消息 WM_COMMAND

菜单、工具栏、按钮等点击时的命令. 消息首先发送到主窗口，由主窗口逐层向子窗口派发。

这类的消息使用的宏：

ON_COMMAND( )

ON_COMMAND_RANGE( )

消息处理时,在OnWndMsg中调用OnCommand处理函数进行消息处理.

3 通知消息 WM_NOTIFY

子窗口对父窗口的通知消息。

控件消息宏,例如: EDIT控件 ON_EN_CHANGE、ON_NOTIFY/ON_NOTIFY_RANGE消息处理时,在OnWndMsg中调用OnNotify(OnCommand)处理函数进行消息处理。

4 自注册消息

用户自注册消息的处理。

用户需调用RegisterWindowMessage函数注册消息,然后在消息映射中使用.

UINT RegisterWindowMessage(

LPCTSTR lpString //消息名字符串

);

返回注册成功的消息ID(0xC000-0xFFFF)

消息映射宏: ON_REGISTERED_MESSAGE

消息处理时, 与窗口消息处理类似,但是在查找消息处理函数和执行消息处理函数时不同.

自注册消息使用举例：

// RegisterMsg.cpp : Defines the entry point for the application. // #include "stdafx.h" //注册消息ID UINT g_nRegMsg = RegisterWindowMessage( "MYREGMSG" ); class CRegsiterFrame : public CFrameWnd { DECLARE_MESSAGE_MAP( ) public: afx_msg int OnCreate( LPCREATESTRUCT lpCreateStruct ); afx_msg void OnTest( ); //消息处理函数 afx_msg LRESULT OnRegMsg( WPARAM wParam,LPARAM lParam ); }; BEGIN_MESSAGE_MAP( CRegsiterFrame, CFrameWnd ) ON_WM_CREATE( ) ON_COMMAND( 1001, OnTest ) //消息宏映射 ON_REGISTERED_MESSAGE( g_nRegMsg, OnRegMsg ) END_MESSAGE_MAP( ) int CRegsiterFrame::OnCreate( LPCREATESTRUCT lpCreateStruct ) {        //父类的OnCreate处理 /*if(!CFrameWnd::OnCreate( lpCreateStruct ) ) { return 0; }*/ //创建按钮 CreateWindow( "BUTTON", "Test", WS_CHILD|WS_VISIBLE, 50, 50, 200, 30, m_hWnd, (HMENU)1001, AfxGetApp()->m_hInstance, NULL ); return 1; } void CRegsiterFrame::OnTest( ) {        //发送消息 SendMessage( g_nRegMsg ); } LRESULT CRegsiterFrame::OnRegMsg( WPARAM wParam,LPARAM lParam ) { AfxMessageBox( "OnRegMsg" ); return 0; } class CRegisterApp : public CWinApp { public: virtual BOOL InitInstance( ); }; CRegisterApp theApp; BOOL CRegisterApp::InitInstance( ) { CRegsiterFrame * pWnd = new CRegsiterFrame( ); pWnd->Create( NULL, "Register Msg" ); m_pMainWnd = pWnd; m_pMainWnd->ShowWindow( SW_SHOW ); m_pMainWnd->UpdateWindow( ); return TRUE; }