学习笔记之深入浅出MFC 第9章仿真MFC 之一

时间：2016-05-07 11:29:29 阅读：317 评论：0 收藏：0 [点我收藏+]

标签：

在文章开始是我们的观点就强调过了，要想用好一个工具，就必须深入了解这个工具的工作原理。而仿真，正是最好的方法。

如何仿真呢？我们在console程序中仿真MFC，这样可以把程序结构的负荷降到最低。作者在仿真中的原则是：简化再简化，简化到不能再简化。请注意，以下所有程序的类层次结构、类名称、变量名称、结构名称、函数名称、函数内容，都以MFC为仿真对象，具体而微。

在档案的安排上，作者把仿真MFC的类集中在MFC.H和MFC.CPP中，把自己派生的类集中在MY.H和MY.CPP中。对于自定义的类，我的命名方式是在父类的名称前面加一个“My”,例如派生自CWinApp者，名为CMyWinApp,派生自CDocument者，名为CMyDoc。

特别说明：我一直认为，扎实的基础是以后进阶高度快速提升的不二法门，所以希望大家能够跟着我沉住气，一点一点挖出MFC整个的运行机制，相信这会对大家和对我自己更有裨益。从这一章开始，我会分析的很细，可能每一节讲的很少，但务必求精不贪多，希望大家可以理解。

1、MFC的类层次结构

首先以一个极简单的程序Frame1，把MFC数个最重要的类的层次关系仿真出来：

技术分享

这个例程仿真MFC的类层次。后续会在这个类层次上开发新的能力。在这些名为Frame?的范例中，我以MFC程序代码为蓝本，尽量仿真MFC的内部行为，并且使用完全相同的类名称、函数名称、变量名称。这会对我们在后面深入探讨MFC时有莫大的助益。

Frame 1 范例程序

首先是MFC.H头文件：

#include <iostream>

using namespace std;
class CObject //基类CObject

{

public:

CObject::CObject() { cout << "CObject Constructor \n"; }

CObject::~CObject() {cout << "CObject Destructor \n"; };

};

class CCmdTarget : public CObject

{

public:

CCmdTarget::CCmdTarget() { cout << "CCmdTarget Constructor \n"; }

CCmdTarget::~CCmdTarget() {cout << "CCmdTarget Destructor \n"; };

};

class CWinThread : public CCmdTarget

{

public:

CWinThread::CWinThread() { cout << "CWinThread Constructor \n"; }

CWinThread::~CWinThread() {cout << "CWinThread Destructor \n"; };

};

class CWinApp : public CWinThread

{

public:

CWinApp* m_pCurrentWinApp;

public:

CWinApp::CWinApp() { m_pCurrentWinApp = this;

cout << "CWinApp Constructor \n"; } //这个类的对象在创建时就会调用构造函数，所以也就把当前类对象指针保存到了m_pCurrentWinAPP

CWinApp::~CWinApp() { cout << "CWinApp Destructor \n"; }

};

class CWnd : public CCmdTarget

{

public:

CWnd::CWnd() { cout << "CWnd Constructor \n"; }

CWnd::~CWnd() { cout << "CWnd Destructor \n"; }

};

class CFrameWnd : public CWnd

{

public:

CFrameWnd::CFrameWnd() { cout << "CFrameWnd Constructor \n"; }

CFrameWnd::~CFrameWnd() { cout << "CFrameWnd Destructor \n"; }

};

class CView : public CWnd

{

public:

CView::CView() { cout << "CView Constructor \n"; }

CView::~CView() { cout << "CView Destructor \n"; }

};

//全局函数

CWinApp* AfxGetApp();

然后是MFC.CPP：

#include "MFC.h"

#include "MY.h"

extern CMyWinApp theApp;

CWinApp* AfxGetApp()

{

return theApp.m_pCurrentWinApp;

}

接下来是从MFC类中派生出来的我们自己的App类：

MY.H头文件：

#include <iostream>

#include "MFC.h"

class CMyWinApp : public CWinApp

{

public:

CMyWinApp::CMyWinApp() { cout << "CMyWinApp Constructor \n"; }

CMyWinApp::~CMyWinApp() { cout << "CMyWinApp Destructor \n"; }

};

class CMyFrameWnd : public CFrameWnd

{

public:

CMyFrameWnd() { cout << "CMyFrameWnd Constructor \n"; }

~CMyFrameWnd() { cout << "CMyFrameWnd Destructor \n"; }

};

MY.CPP源文件：

#include "MY.h"

CMyWinApp theApp;

void main()

{

CWinApp* pApp = AfxGetApp();

}

执行的结果：

CObject Constructor

CCmdTarget Constructor

CWinThread Constructor

CWinApp Constructor

CMyWinApp Constructor

CMyWinApp Destructor

CWinApp Destructor

CWinThread Destructor

CCmdTarget Destructor

CObject Destructor

从程序中可以看到，Frame1并没有new任何对象，反倒是有一个全局对象theApp存在。C++规定，全局对象的建构将比程序进入点（在DOS环境为main，在Windows环境为WinMain）更早。所以theApp的构造函数将更早于main。换句话说，你所看到的执行结果中的那些构造函数输出操作全都是在main函数之前完成的。

在解释一下，因为定义theApp这个全局变量的类为CMyWinApp，而这个类是从一系列基类继承下来的，也就意味着你在声明这个全局变量的时候，就已经依次调用了各个类的构造函数和析构函数，所以才会有上面的输出结果。

main函数调用全局函数AfxGetApp以取得theApp的对象指针。这完全是仿真MFC程序的手法。

2、MFC程序的初始化过程

MFC程序也是一个Window程序，它的内部一定也像第1章所述的一样，有窗口注册操作，有窗口产生操作，有消息循环操作，也有窗口函数。这里我们只交代一个程序流程，这个流程正是任何MFC程序的初始化过程的简化。

以下是Frame2范例程序的类层次及其成员。对于那些“除了构造函数与解构函数之外没有其他成员”的类，我们就不在图中展开它们了。

就如曾在第1章解释过的，InitApplication和InitInstance现在成了MFC的CWinApp的两个虚拟函数。前者负责“每个程序只做一次”的操作，后者负责“每一个例程都得做一次”的操作。

通常，系统会为你注册一些标准的窗口类（当然也就准备好了一些标准的窗口函数），应用程序设计者应该在你的CMyWinApp中改写InitInstance，并在其中把窗口产生出来-----这样你才有机会在标准的窗口类中指定自己的窗口标题和菜单。下面是我们新的main函数：

//MY.CPP

CMyWinApp theApp;

void main()

{

CWinApp* pApp = AfxGetApp();

pApp->InitApplication();

pApp->InitInstance();

pApp->Run();

}

其中，pApp指向theApp全局对象。这里我们开始看到了虚拟函数的妙用：

pApp->InitApplication()调用的是CWinApp::InitApplication,

pApp->InitInstance() 调用的是CMyWinApp::InitInstance( 因为CMyWinApp改写了它)，

pApp->Run()调用的是CWinApp::Run，

好，请注意一下CMyWinApp::InitInstance的操作，以及它所引发的行为：

BOOL CMyWinApp::InitInstance()

{

cout << "CMyWinApp::InitInstance \n";

m_pMainWnd = new CMyFrameWnd; //还记得吗？动态创建时引发CMyFrameWnd::CMyFrameWnd构造函数

return TRUE;

}

CMyFrameWnd::CMyFrameWnd()

{

Create(); //Create是虚拟函数，但是CMyFrameWnd未改写它，所以引发父类的CFrameWnd::Create

}

BOOL CFrameWnd::Create()

{

cout << " CFrameWnd::Create \n";

CreateEx(); //CreateEx是虚拟函数，但CFrameWnd未改写之，所以引发CWnd::CreateEx

return TRUE;

}

BOOL CWnd :: CreateEx()

{

cout << " CWnd:: CreateEx \n";

PreCreateWindow(); //这是一个虚拟函数，CWnd中有定义，CFrameWnd也改写了它。那么你说这里到底是调用CWnd::PreCreateWindow还是CFrameWnd::PreCreateWindow呢？

return TRUE;

}

BOOL CFrameWnd :: PreCreateWindow()

{

cout<<"CFrameWnd::PreCreateWindow \n";

return TRUE;

}

其实，这里调用的是CFrameWnd::PreCreateWindow。这便是第2章的“Object slicing与虚拟函数”一节所说的“虚拟函数的一个极重要的行为方式”。

当然，在这里这些函数什么动作也没做，只是输出一个标识字符串，我们现在主要的目的是让你先熟悉MFC程序的流程。

执行结果：

CWinApp::InitApplication

CMyWinApp::InitInstance

CMyFrameWnd::CMyFrameWnd

CFrameWnd::Create

CWnd::CreateEx

CFrameWnd::PreCreateWindow

CWinApp::Run

CWinThread::Run

Frame2范例程序

MFC.H头文件

#define BOOL int

#define TRUE 1

#define FALSE 0

#include <iostream>

using namespace std;

class CObject //基类CObject

{

public:

CObject::CObject() { }

CObject::~CObject() { }

};

class CCmdTarget : public CObject

{

public:

CCmdTarget::CCmdTarget() { }

CCmdTarget::~CCmdTarget() { }

};

class CWinThread : public CCmdTarget

{

public:

CWinThread::CWinThread() { }

CWinThread::~CWinThread() { }

virtual BOOL InitInstance()

{

cout <<"CWinThread :: InitInstance \n";

return TRUE;

}

virtual BOOL Run()

{

cout <<"CWinThread :: Run \n";

return TRUE;

}

};

class CWinApp : public CWinThread

{

public:

CWinApp* m_pCurrentWinApp;

CWnd* m_pMainWnd;

public:

CWinApp::CWinApp() { m_pCurrentWinApp = this;}

CWinApp::~CWinApp() { }

virtual BOOL InitApplication()

{

cout <<"CWinApp :: InitApplication \n";

return TRUE;

}

virtual BOOL InitInstance()

{

cout <<"CWinApp :: InitInstance \n";

return TRUE;

}

virtual BOOL Run()

{

cout <<"CWinApp :: Run \n";

return CWinThread::Run();

}

};

class CWnd : public CCmdTarget

{

public:

CWnd::CWnd() { }

CWnd::~CWnd() { }

virtual BOOL Create();

BOOL CreateEx();

virtual BOOL PreCreateWindow();

};

class CFrameWnd : public CWnd

{

public:

CFrameWnd::CFrameWnd() { }

CFrameWnd::~CFrameWnd() { }

BOOL Create();

virtual BOOL PreCreateWindow();

};

class CView : public CWnd

{

public:

CView::CView() { }

CView::~CView() { }

};

//全局函数

CWinApp* AfxGetApp();

MFC.CPP源文件：

#include "MFC.h"

#include "MY.h"

extern CMyWinApp theApp;

CWinApp* AfxGetApp()

{

return theApp.m_pCurrentWinApp;

}

BOOL CWnd::Create()

{

cout << "CWnd ::Create \n";

return TRUE;

}

BOOL CWnd::CreateEx()

{

cout<<"CWnd::CreateEx \n";

PreCreateWindow();

return TRUE;

}

BOOL CWnd::PreCreateWindow()

{

cout << "CWnd ::PreCreateWindow \n";

return TRUE;

}

BOOL CFrameWnd::Create()

{

cout<<"CFrameWnd::Create \n";

CreateEx();

return TRUE;

}

BOOL CFrameWnd::PreCreateWindow()

{

cout<<"CFrameWnd::PreCreateWindow \n";

return TRUE;

}

MY.H头文件

#include <iostream>

#include "MFC.h"

class CMyWinApp : public CWinApp

{

public:

CMyWinApp::CMyWinApp() { }

CMyWinApp::~CMyWinApp() { }

virtual BOOL InitInstance();

};

class CMyFrameWnd : public CFrameWnd

{

public:

CMyFrameWnd();

~CMyFrameWnd() { cout << "CMyFrameWnd Destructor \n"; }

};

MY.CPP源文件：

#include "MY.h"

CMyWinApp theApp;

BOOL CMyWinApp::InitInstance()

{

cout<<"CMyWinApp::InitInstance \n";

m_pMainWnd = new CMyFrameWnd;

return TRUE;

}

CMyFrameWnd::CMyFrameWnd()

{

cout<<"CMyFrameWnd::CMyFrameWnd \n";

Create();

}

void main()

{

CWinApp* pApp = AfxGetApp();

pApp->InitApplication();

pApp->InitInstance();

pApp->Run();

}