原文地址：

 很多做軟體開發的人都有一種對事情刨根問底的精神，例如我們一直在用的MFC，很方便，不用學太多原理性的知識就可以做出各種視窗程式，但喜歡鑽研的朋友肯定想知道，到底微軟幫我們做了些什麼，讓我們在它的框架下可以簡單的寫程式。本文開始就跟大家分享一位同行前輩寫的MFC核心機制分析（稍作整理），語言樸實易懂，在讀完此深入淺析的剖析系列後，相信留給大家的是對MFC執行機制的深入理解。

       MFC六大核心機制概述

       我們選擇了C++，主要是因為它夠藝術、夠自由，使用它我們可以實現各種想法，而MFC將多種可靈活使用的功能封裝起來，我們豈能忍受這種“黑盒”操作？於是研究分析MFC的核心機制成為必然。

       首先，列出要講的MFC六大核心機制：

       1、MFC程式的初始化。
       2、執行時型別識別（RTTI）。
       3、動態建立。
       4、永久儲存。
       5、訊息對映。
       6、訊息傳遞。

       本文講第一部分，MFC程式的初始化過程。

       簡單的MFC視窗程式

       設計一個簡單完整MFC程式，產生一個視窗。當然這不能讓AppWizard自動為我們生成。我們可以在Win32 Application工程下面那樣寫：

1. #include <afxwin.h> 
2. class MyApp : public CWinApp   
3. {   
4. public:   
5. BOOL InitInstance()  //②程式入點 
6. {   
7.   CFrameWnd *Frame=new CFrameWnd();//構造框架 
8.   m_pMainWnd=Frame; //將m_pMainWnd設定為Frame; 
9.   Frame->Create(NULL,"最簡單的視窗");//建立框架 
10.   Frame->ShowWindow(SW_SHOW);  //顯示框架 
11. returntrue;         //返回 
12.  }   
13. };   
14. MyApp theApp;  //①建立應用程式。

       設定連結MFC庫，執行，即可看見一個視窗。

       從上面，大家可以看到建立一個MFC視窗很容易，只用兩步：一是從CWinApp派生一個應用程式類（這裡是MyApp），然後建立應用程式物件（theApp），就可以產生一個自己需要的視窗（即需要什麼樣就在InitInstance()裡建立就行了）。

       整個程式，就改寫一個InitInstance()函式，建立那麼一個物件（theApp），就是一個完整的視窗程式。這就是“黑盒”操作的魔力！

       在我們正想為微軟鼓掌的時候，我們突然覺得心裡空蕩蕩的，我們想知道微軟幫我們做了什麼事情，而我們想編自己的程式時又需要做什麼事情，哪怕在上面幾行的程式裡面，我們還有不清楚的地方，比如，幹嘛有一個m_pMainWnd指標變數，它從哪裡來，又要到哪裡去呢？想一想在DOS下程式設計是多麼美妙的一件事呵，我們需要什麼變數，就宣告什麼變數，需要什麼樣的函式，就編寫什麼樣的函式，或者引用函式庫……但是現在我們怎麼辦？

       我們可以逆向思維一下，MFC要達到這種效果，它是怎麼做的呢？首先我們要弄明白，VC++不是一種語言，它就象我們學c語言的時候的一個類似記事本的編輯器（請原諒我的不貼切的比喻），所以，在VC裡面我們用的是C++語言程式設計，C++才是根本（初學者總是以為VC是一門什麼新的什麼語言，一門比C++先進很多的複雜語言，汗）。說了那麼多，我想用一句簡單的話概括“MFC黑箱’，就是為我們的程式加入一些固化的‘C++程式碼’的東西”。

       既然MFC黑箱幫我們加入了程式碼，那麼大家想想它會幫我們加入什麼樣的程式碼呢？他會幫我們加入求解一元二次方程的程式碼嗎？當然不會，所以它加入的實際上是每次編寫視窗程式必須的，通用的程式碼。

       再往下想，什麼才是通用的呢？我們每次視窗程式設計都要寫WinMain()函式，都要有註冊視窗，產生視窗，訊息迴圈，回撥函式……即然每次都要的東西，就讓它們從我們眼前消失，讓MFC幫忙寫入！

       手動模擬MFC程式的初始化      

       要知道MFC初始化過程，大家當然可以跟蹤執行程式。但這種跟蹤很麻煩，我相信大家都會跟蹤的暈頭轉向。本人覺得哪怕你理解了MFC程式碼，也很容易讓人找不著北，我們完全不懂的時候，在成千上萬行程式的迷宮中如何能找到出口？

       我們要換一種方法，不如就來重新編寫個MFC庫吧，譁！大家不要笑，小心你的大牙，我不是瘋子（雖然瘋子也說自己不瘋）。我們要寫的就是最簡單的MFC類庫，就是把MFC巨集觀上的，理論上的東西寫出來。我們要用最簡化的程式碼，簡化到剛好能執行。

       1、需要“重寫”的MFC庫

       既然，我們這一節寫的是MFC程式的初始化過程，上面我們還有了一個可執行的MFC程式。程式中只是用了兩個MFC類，一個是CWinApp，另一個是CFrameWnd。當然，還有很多同樣重要MFC類如檢視類，文件類等等。但在上面的程式可以不用到，所以暫時省去了它（總之是為了簡單）。

       好，現在開始寫MFC類庫吧……唉，面前又有一個大難題，就是讓大家背一下MFC層次結構圖。天，那張魚網怎麼記得住，但既然我們要理解他，總得知道它是從那裡派生出來的吧。

       考慮到大家都很辛苦，那我們看一下上面兩個類的父子關係（箭頭代表派生）：

       CObject->CCmdTarget->CWinThread->CWinApp->自己的重寫了InitInstance()的應用程式類。
       CObject（同上）->CCmdTarget（同上）->CWnd->CFrameWnd

       看到層次關係圖之後，終於可以開始寫MFC類庫了。按照上面層次結構，我們可以寫以下六個類（為了直觀，省去了建構函式和解構函式）。

1. ///////////////////////////////////////////////////////// 
2. class CObiect{};//MFC類的基類。 
3. class CCmdTarget : public CObject{};   
4. ------------------------------------------------   
5. class CWinThread : public CCmdTarget{};   
6. class CWinApp : public CWinThread{};   
7. ------------------------------------------------   
8. class CWnd : public CCmdTarget{};   
9. class CFrameWnd : public CWnd{};   
10. /////////////////////////////////////////////////////////

       大家再想一下，在上面的類裡面，應該有什麼？大家馬上會想到，CWinApp類或者它的基類CCmdTarget裡面應該有一個虛擬函式virtual BOOL InitInstance()，是的，因為那裡是程式的入口點，初始化程式的地方，那自然少不了的。可能有些朋友會說，反正InitInstance()在派生類中一定要過載，我不在CCmdTarget或CWinApp類裡定義，留待CWinApp的派生類去增加這個函式可不可以。扯到這個問題可能有點越說越遠，但我想信C++的朋友對虛擬函式應該是沒有太多的問題的。總的來說，作為程式設計師如果清楚知道基類的某個函式要被派生類用到，那定義為虛擬函式要方便很多。

       也有很多朋友問，C++為什麼不自動把基類的所有函式定義為虛擬函式呢，這樣可以省了很多麻煩，這樣所有函式都遵照派生類有定義的函式就呼叫派生類的，沒定義的就呼叫基類的，不用寫virtual的麻煩多好！其實，很多面向物件的語言都這樣做了。但定義一個虛擬函式要生成一個虛擬函式表，要佔用系統空間，虛擬函式越多，表就越大，有時得不償失！這裡哆嗦幾句，是因為往後要說明的訊息對映中大家更加會體驗到這一點，好了，就此打往。

       上面我們自己解決了一個問題，就是在CCmdTarge寫一個virtual BOOL InitInstance()。

      2、WinMain()函式和CWinApp類

       大家再往下想，我們還要我們MFC“隱藏”更多的東西：WinMain()函式，設計視窗類，視窗註冊，訊息迴圈，回撥函式……我們馬上想到封裝想封裝他們。大家似乎隱約地感覺到封裝WinMain()不容易，覺得WinMain()是一個特殊的函式，許多時候它代表了一個程式的起始和終結。所以在以前寫程式的時候，我們寫程式習慣從WinMain()的左大括寫起，到右大括弧返回、結束程式。

       我們換一個角度去想，有什麼東西可以拿到WinMain()外面去做，許多初學者們，總覺得WinMain()函式是天大的函式，什麼函式都好象要在它裡面才能真正執行。其實這樣瞭解很片面，甚至錯誤。我們可以寫一個這樣的C++程式：

1. //////////////////////////////////////////////////// 
2. #include <iostream.h> 
3. class test{   
4. public:   
5.  test(){cout<<"請改變你對main()函式的看法！"<<endl;}   
6. };   
7. test test1;   
8. /**************************/
9. void main(){}   
10. ////////////////////////////////////////////////////

       在上面的程式裡，入口的main()函式表面上什麼也不做，但程式執行了（注：實際入口函式做了一些我們可以不瞭解的事情），並輸出了一句話（注：全域性物件比main()首先執行）。現在大家可以知道我們的WinMain()函式可以什麼都不做，程式依然可以執行，但沒有這個入口函式程式會報錯。

       那麼WinMain()函式會放哪個類上面呢，請看下面程式：

1. #include <afxwin.h> 
2. class MyApp : public CWinApp   
3. {   
4. public:   
5. BOOL InitInstance()  //②程式入點 
6.  {   
7.   AfxMessageBox("程式依然可以執行！");   
8. returntrue;   
9.  }   
10. };   
11. MyApp theApp;  //①建立應用程式。

       大家可以看到，我並沒有構造框架，而程式卻可以運行了——彈出一個對話方塊（如果沒有WinMain()函式程式會報錯）。上面我這樣寫還是為了直觀起見，其實我們只要寫兩行程式：

       #include <afxwin.h>
       CWinApp theApp;     //整個程式只構造一個CWinApp類物件，程式就可以執行！

       所以說，只要我們構造了CWinApp物件，就可以執行WinMain()函式。我們馬上相信WinMain()函式是在CWinApp類或它的基類中，而不是在其他類中。其實這種看法是錯誤的，我們知道編寫C++程式的時候，不可能讓你在一個類中包含入口函式，WinMain()是由系統呼叫，跟我們的平時程式自身呼叫的函式有著本質的區別。我們可以暫時簡單想象成，當CWinApp物件構造完的時候，WinMain()跟著執行。

       現在大家明白了，大部分的“通用程式碼（我們想封裝隱藏的東西）”都可以放到CWinApp類中，那麼它又是怎樣執行起來的呢？為什麼構造了CWinApp類物件就“自動”執行那麼多東西。

       大家再仔細想一下，CWinApp類物件構造之後，它會“自動”執行自己的建構函式。那麼我們可以把想要“自動”執行的程式碼放到CWinApp類的建構函式中。

       那麼CWinApp類可能打算這樣設計（先不計較正確與否）：

1. class CWinApp : public CWinThead{   
2. public:   
3. virtualBOOL InitInstance(); //解釋過的程式的入點 
4.   CWinApp ::CWinApp(){   //建構函式 
5. //////////////////////// 
6.    WinMain();   //這個是大家一眼看出的錯誤 
7.    Create();    //設計、建立、更新顯示視窗 
8.    Run();     //訊息迴圈 
9. ////////////////////// 
10. }   
11. };  

       寫完後，大家又馬上感覺到似乎不對，WinMain()函式在這裡好象真的一點用處都沒有，並且能這樣被呼叫嗎（請允許我把手按在聖經上宣告一下：WinMain()不是普通的函式，它要肩負著初始化應用程式，包括全域性變數的初始化，是由系統而不是程式本身呼叫的，WinMain()返回之後，程式就結束了，程序撤消）。再看Create()函式，它能確定設計什麼樣的視窗，建立什麼樣的視窗嗎？如果能在CWinApp的建構函式裡確定的話，我們以後設計MFC程式時視窗就一個樣，這樣似乎不太合理。

       回過頭來，我們可以讓WinMain()函式一條語句都不包含嗎？不可以，我們看一下WinMain() 函式的四個引數：

       WinMain(HINSTANCE, HINSTANCE, LPSTR, int)

       其中第一個引數指向一個例項控制代碼，我們在設計WNDCLASS的時候一定要指定例項控制代碼。我們視窗程式設計，肯定要設計視窗類。所以，WinMain()再簡單也要這樣寫：

       int WinMain(HINSTANCE hinst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
       {  hInstance=hinst }

       既然例項控制代碼要等到程式開始執行才能知道，那麼我們用於建立視窗的Create()函式也要在WinMain()內部才能執行（因為如果等到WinMain()執行完畢後，程式結束，程序撤消，當然Create()也不可能建立視窗）。

       再看Run()（訊息迴圈）函式，它能在WinMain()函式外面執行嗎？眾所周知，訊息迴圈就是相同的那麼幾句程式碼，但我們也不要企圖把它放在WinMain()函式之外執行。

       所以我們的WinMain()函式可以像下面這樣寫：

       WinMain(……)
       {
              ……視窗類物件執行建立視窗函式……
              ……程式類物件執行訊息迴圈函式……
       }

       對於WinMain()的問題，得總結一下，我們封裝的時候是不可以把它封裝到CWinApp類裡面，但由於WinMain()的不變性（或者說有規律可循），MFC完全有能力在我們構造CWinApp類物件的時候，幫我們完成那幾行程式碼。

       轉了一個大圈，我們彷彿又回到了SDK程式設計的開始。但現在我們現在能清楚地知道，表面上MFC與SDK程式設計截然不同，但實質上MFC只是用類的形式封裝了SDK函式，封裝之後，我們在WinMain()函式中只需要幾行程式碼，就可以完成一個視窗程式。我們也由此知道了應如何去封裝應用程式類（CWinApp）和主框架視窗類（CFrameWnd）。下面把上開始設計這兩個類。

       3、MFC庫的“重寫”

       為了簡單起見，我們忽略這兩個類的基類和派生類的編寫，可能大家會認為這是一種很不負責任的做法，但本人覺得這既可減輕負擔，又免了大家在各類之間穿來穿去，更好理解一些（我們在關鍵的地方作註明）。還有，我把全部程式碼寫在同一個檔案中，讓大家看起來不用那麼吃力，但這是最不提倡的寫程式碼方法，大家不要學哦！

1. #include <windows.h> 
2. HINSTANCE hInstance;   
3. class CFrameWnd     
4. {   
5. HWND hwnd;   
6. public:   
7.  CFrameWnd();   //也可以在這裡呼叫Create() 
8. virtual ~CFrameWnd();   
9. int Create();    //類就留意這一個函式就行了！ 
10. BOOL ShowWnd();   
11. };   
12. class CWinApp1     
13. {   
14. public:   
15.  CFrameWnd* m_pMainWnd;//在真正的MFC裡面 
16. //它是CWnd指標，但這裡由於不寫CWnd類 
17. //只要把它寫成CFrameWnd指標 
18.  CWinApp1* m_pCurrentWinApp;//指向應用程式物件本身 
19.  CWinApp1();   
20. virtual ~CWinApp1();   
21. virtualBOOL InitInstance();//MFC原本是必須過載的函式，最重要的函式！！！！
22. virtualBOOL Run();//訊息迴圈 
23. };   
24. CFrameWnd::CFrameWnd(){}   
25. CFrameWnd::~CFrameWnd(){}   
26. int CFrameWnd::Create()   //封裝建立視窗程式碼 
27. {   
28.  WNDCLASS wndcls;   
29.  wndcls.style=0;   
30.  wndcls.cbClsExtra=0;   
31.  wndcls.cbWndExtra=0;   
32.  wndcls.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH);   
33.  wndcls.hCursor=LoadCursor(NULL,IDC_CROSS);   
34.  wndcls.hIcon=LoadIcon(NULL,IDC_ARROW);   
35.  wndcls.hInstance=hInstance;   
36.  wndcls.lpfnWndProc=DefWindowProc;//預設視窗過程函式。 
37. //大家可以想象成MFC通用的視窗過程。 
38.  wndcls.lpszClassName="視窗類名";   
39.  wndcls.lpszMenuName=NULL;   
40.  RegisterClass(&wndcls);   
41.  hwnd=CreateWindow("視窗類名","視窗例項標題名",WS_OVERLAPPEDWINDOW,0,0,600,400,NULL,NULL,hInstance,NULL);   
42. return 0;   
43. }   
44. BOOL CFrameWnd::ShowWnd()//顯示更新視窗 
45. {   
46.  ShowWindow(hwnd,SW_SHOWNORMAL);   
47.  UpdateWindow(hwnd);   
48. return 0;   
49. }   
50. ///////////// 
51. CWinApp1::CWinApp1()   
52. {   
53.  m_pCurrentWinApp=this;   
54. }   
55. CWinApp1::~CWinApp1(){}   
56. //以下為InitInstance()函式，MFC中要為CWinApp的派生類改寫， 
57. //這裡為了方便理解，把它放在CWinApp類裡面完成！ 
58. //你只要記住真正的MFC在派生類改寫此函式就行了。 
59. BOOL CWinApp1::InitInstance()   
60. {   
61.  m_pMainWnd=new CFrameWnd;   
62.  m_pMainWnd->Create();   
63.  m_pMainWnd->ShowWnd();   
64. return 0;   
65. }   
66. BOOL CWinApp1::Run()//////////////////////封裝訊息迴圈 
67. {   
68.  MSG msg;   
69. while(GetMessage(&msg,NULL,0,0))   
70.  {   
71.   TranslateMessage(&msg);   
72.   DispatchMessage(&msg);   
73.  }   
74. return 0;   
75. } //////////////////////////////////////////////////////封裝訊息迴圈 
76. CWinApp1 theApp;   //應用程式物件（全域性） 
77. int WINAPI WinMain( HINSTANCE hinst, HINSTANCE hPrevInstance,   LPSTR lpCmdLine,  int nCmdShow)   
78. {   
79.  hInstance=hinst;   
80.  CWinApp1* pApp=theApp.m_pCurrentWinApp;   
81. //真正的MFC要寫一個全域性函式AfxGetApp，以獲取CWinApp指標。 
82.  pApp->InitInstance();   
83.  pApp->Run();   
84. return 0;   
85. }  

       程式碼那麼長，實際上只是寫了三個函式，一是CFrameWnd類的Create()，第二個是CWinApp類的InitInstance()和Run()。在此特別要說明的是InitInstance()，真正的MFC中，那是我們跟據自己構造視窗的需要，自己改寫這個函式。

       大家可以看到，封裝了上面兩個類以後，在入口函式WinMain中就寫幾行程式碼，就可以產生一個視窗程式。在MFC中，因為WinMain函式就是固定的那麼幾行程式碼，所以MFC絕對可以幫我們自動完成（MFC的特長就是幫我們完成有規律的程式碼），也因此我們建立MFC應用程式的時候，看不到WinMain函式。

分享源自：http://blog.csdn.net/liyi268/article/details/297875