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;

}