MFC应用程序编程

MFC应用程序编程

转自http://www.cnblogs.com/tangzhengyue/p/3153825.html

一 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; }