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

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

如何仿真呢？我们在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

CMyWin
12832
App  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();
}

程序过程有些繁琐，所以我绘制了一下流程图，从总体上来看整个过程，应该更有注意理解：



下面是在InitInstance()中创建窗口的过程：