MFC再学习（一）单文档程序刨根究底

温故而知新。在.NET等等新技术前面，MFC虽然有些老旧，甚至是显得晦涩和有些奇技淫巧，但是其中的很多思想还是值得我们学习的。侯捷老师的《深入浅出MFC》基本是学习MFC的必读教材，但是因为年代久远，MFC内部也有不少东西发生了变化，而后又有《MFC技术内幕系列》，但又是基于MDI的。于是我觉得有必要从头再梳理一遍，算是做个备忘，也是个再学习的过程。让我们从单文档程序的生死流程开始。请注意本文会对许多细节进行更深的挖掘，因此会有很多源码，也许读起来会有些累。

 

首先用向导生成一个单文档程序，项目名称为SDI（本文均基于MFC10.0)。

1.进入WinMain前的准备工作

shell调用win32 API函数CreateProcess激活我们的应用程序实例，也就是建立一个「进程核心对象」，并为此进程建立一个4GB的 地址空间。加载器将必要的码加载到上述地址空间中，包括App.exe 的程序、资料，以及所需的动态联结函数库（DLLs）。系统为此进程建立一个执行线程，称为主执行线程（primary thread），同时调用C Runtime Library中的启动函数，

该函数共有4个版本，对应如下：

它们都定义在VS安装目录/VC/crt/src/crt0.c中，这里将被调用的是WinMainCRTStartup。

而实际上他们所作的工作是一样的，crt0.c中有如下这一段：

#ifdef _WINMAIN_

#ifdef WPRFLAG

#define _tmainCRTStartup   wWinMainCRTStartup

#else  /*WPRFLAG */

#define _tmainCRTStartup   WinMainCRTStartup

#endif  /*WPRFLAG */

#else  /*_WINMAIN_ */

#ifdef WPRFLAG

#define _tmainCRTStartup    wmainCRTStartup

#else  /*WPRFLAG */

#define _tmainCRTStartup    mainCRTStartup

#endif  /*WPRFLAG */

#endif  /*_WINMAIN_ */

实际上会调用哪个启动函数就是由_WINMAIN_和WPRFLAG这两个宏来定义的，而他们实质上都是_tmainCRTStartup，而_tmainCRTStartup又调用__tmainCRTStartup，其原型如：

__declspec(noinline)int __tmainCRTStartup(void )

 

__declspec(noinline)是告诉编译器不要将其作为内联函数，在这个函数中主要做了1.调用_heap_init函数创建堆空间，调用_mtinit启用多线程 2.RTC,低级IO初始化 3.获取命令行缓冲区、环境变量的指针，并设置命令行参数与环境变量4. 调用_cinit初始化C和C++数据，包括初始化浮点计算包，调用_initterm( __xi_a,__xi_z)执行注册，PE文件数据区的初始化函数，调用_initterm(__xc_a, __xc_z)执行C++的初始化，这其中就会通过一个指针来遍历成员函数指针表，分别调用各个全局对象的构造函数，代表着我们程序的CSDIApp的唯一实例化对象theApp也在这时被构造（最终调用的是基类CWinApp的构造函数），这时theApp中的成员变量都是空值，将在之后被重新赋值。

_initterm函数的代码如下：

#ifdef CRTDLL

void __cdecl _initterm (

#else  /* CRTDLL */

static void __cdecl _initterm (

#endif  /* CRTDLL */

        _PVFV* pfbegin,

        _PVFV* pfend

        )

{

        /*

         *walk the table of function pointers from the bottom up, until

         *the end is encountered.  Do not skip the first entry.  The initial

         *value of pfbegin points to the first valid entry.  Do not try to

         *execute what pfend points to.  Only entries before pfend are valid.

         */

        while( pfbegin < pfend )

        {

            /*

             *if current table entry is non-NULL, call thru it.

             */

            if( *pfbegin != NULL )//遍历

                (**pfbegin)();//全局对象构造函数调用

            ++pfbegin;

        }

}

然后根据_WINMAIN_宏是否被定义来调用了_tWinMain或者_tmain，根据UNICODE宏是否被定义来调用相应的版本。

crt0.c中有如下这一段：

#ifdef _WINMAIN_

          lpszCommandLine = _twincmdln();

          mainret = _tWinMain( (HINSTANCE)&__ImageBase,

                                 NULL,

                                lpszCommandLine,

                                 StartupInfo.dwFlags &STARTF_USESHOWWINDOW

                                      ?StartupInfo.wShowWindow

                                      :SW_SHOWDEFAULT

                                );

#else /* _WINMAIN_ */

           _tinitenv = _tenviron;

           mainret = _tmain(__argc, _targv, _tenviron);

 

tchar.h中有如下这一段：

#ifdef_UNICODE

#define_tmain      wmain

#define_tWinMain   wWinMain

#else   /* ndef _UNICODE */

#define_tmain      main

#define_tWinMain   WinMain

#endif

 

2.进入WinMain函数

全局对象TheApp被构造出来之后，就进入了WinMain函数。WinMain函数并非由用户编写，而是由MFC事先提供的，在链接时由链接器加入用户代码中。WinMain函数只是调用了AfxWinMain，这才是MFC程序真正的入口。

代码如下：

extern "C" int WINAPI _tWinMain(HINSTANCEhInstance, HINSTANCE hPrevInstance,

LPTSTR lpCmdLine, int nCmdShow)

{

// call shared/exported WinMain

return AfxWinMain(hInstance, hPrevInstance, lpCmdLine,nCmdShow);

}

 

2.1 AfxWinMain的调用

代码如下：

int AFXAPI AfxWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,

    _In_ LPTSTR lpCmdLine, intnCmdShow)

{

    ASSERT(hPrevInstance == NULL);

    int nReturnCode = -1;

    CWinThread* pThread = AfxGetThread();

    CWinApp* pApp = AfxGetApp();

    // AFX internal initialization

    if (!AfxWinInit(hInstance,hPrevInstance, lpCmdLine, nCmdShow))

        goto InitFailure;

    // App global initializations (rare)

    if (pApp != NULL && !pApp->InitApplication())

        goto InitFailure;

    // Perform specific initializations

    if (!pThread->InitInstance())

    {

        if (pThread->m_pMainWnd !=NULL)

        {

            TRACE(traceAppMsg, 0, "Warning:Destroying non-NULL m_pMainWnd\n");

            pThread->m_pMainWnd->DestroyWindow();

        }

        nReturnCode = pThread->ExitInstance();

        goto InitFailure;

    }

    nReturnCode = pThread->Run();

InitFailure:

#ifdef _DEBUG

    // Check for missing AfxLockTempMapcalls

    if(AfxGetModuleThreadState()->m_nTempMapLock != 0)

    {

        TRACE(traceAppMsg, 0, "Warning:Temp map lock count non-zero (%ld).\n",

            AfxGetModuleThreadState()->m_nTempMapLock);

    }

    AfxLockTempMaps();

    AfxUnlockTempMaps(-1);

#endif

    AfxWinTerm();

    return nReturnCode;

}

可以看出，在AfxWinMain函数中，首先获取了主线程以及程序实例的指针，通过这两个指针来完成4大部分的工作，分别是AfxWinInit，InitApplication， InitInstance和Run。注意，这一部分已经与《深入浅出MFC》时的MFC4.x有了一定区别

 

2.1.1 AfxWinInit的调用

代码如下：

BOOL AFXAPI AfxWinInit(_In_HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance,

    _In_z_ LPTSTR lpCmdLine, _In_ intnCmdShow)

{

    ASSERT(hPrevInstance == NULL);

    // handle critical errors and avoidWindows message boxes

    SetErrorMode(SetErrorMode(0) |

        SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);

    // set resource handles

    AFX_MODULE_STATE* pModuleState = AfxGetModuleState();

    pModuleState->m_hCurrentInstanceHandle = hInstance;

    pModuleState->m_hCurrentResourceHandle = hInstance;

    pModuleState->CreateActivationContext();

 

    // fill in the initial state for theapplication

    CWinApp* pApp = AfxGetApp();

    if (pApp != NULL)

    {

        // Windows specific initialization(not done if no CWinApp)

        pApp->m_hInstance = hInstance;

        hPrevInstance; // Obsolete.

        pApp->m_lpCmdLine = lpCmdLine;

        pApp->m_nCmdShow = nCmdShow;

        pApp->SetCurrentHandles();

    }

    // initialize thread specific data (formain thread)

    if (!afxContextIsDLL)

        AfxInitThread();

    return TRUE;

}

可以看出AfxWinMain函数主要是做了一些初始化工作。将theApp的几个主要成员变量，赋值成通过参数形式传递进来的WinMain函数的4个参数。随后调用AfxInitThread()为主线程进行初始化。（源代码《深入浅出MFC》 P371提供了，这里不再赘述）

 

2.1.2 InitApplication的调用

InitApplication是个虚函数，一般不需要重载，因此通过pApp调用的是基类的CWinApp::InitApplication();

源代码如下：

BOOL CWinApp::InitApplication()

{

    if(CDocManager::pStaticDocManager != NULL)

    {

        if (m_pDocManager == NULL)

            m_pDocManager = CDocManager::pStaticDocManager;

        CDocManager::pStaticDocManager = NULL;

    }

    if (m_pDocManager != NULL)

        m_pDocManager->AddDocTemplate(NULL);

    else

        CDocManager::bStaticInit = FALSE;

    LoadSysPolicies();

    return TRUE;

}

这里CDocManager::pStaticDocManager和m_pDocManager都为NULL，所以做的操作就是将CDocManager::bStaticInit 赋值为FALSE，这是个static的bool变量，当文档模板是静态初始化的时候应当置为true，否则应为false，我们这里是动态在堆上构造的。LoadSysPolicies()具体做了什么不太清楚，应该也无关紧要。

 

2.1.3 InitInstance的调用

InitApplication运行结束之后，将通过pThread调用InitInstance，这也是单文档程序中最重要的函数，窗口的注册，创建和显示都在这里完成。这也是个虚函数，我们应当在CSDIApp中重载这个函数。

函数定义如下：

BOOL CSDIApp::InitInstance()

{

    // 如果一个运行在 Windows XP 上的应用程序清单指定要

    // 使用 ComCtl32.dll 版本 6 或更高版本来启用可视化方式，

    //则需要 InitCommonControlsEx()。否则，将无法创建窗口。

    INITCOMMONCONTROLSEX InitCtrls;

    InitCtrls.dwSize = sizeof(InitCtrls);

    // 将它设置为包括所有要在应用程序中使用的

    // 公共控件类。

    InitCtrls.dwICC = ICC_WIN95_CLASSES;

    InitCommonControlsEx(&InitCtrls);

    CWinAppEx::InitInstance();

    // 初始化 OLE 库

    if (!AfxOleInit())

    {

        AfxMessageBox(IDP_OLE_INIT_FAILED);

        return FALSE;

    }

    AfxEnableControlContainer();

    EnableTaskbarInteraction(FALSE);

    // 使用 RichEdit 控件需要  AfxInitRichEdit2()  

    // AfxInitRichEdit2();

    // 标准初始化

    // 如果未使用这些功能并希望减小

    // 最终可执行文件的大小，则应移除下列

    // 不需要的特定初始化例程

    // 更改用于存储设置的注册表项

    // TODO: 应适当修改该字符串，

    // 例如修改为公司或组织名

    SetRegistryKey(_T("boli's app"));//这里是准备在注册表HKEY_CURRENT_USER\\software 下面生成一个boli's app分支~为什么说是准备呢？因为如果不调用相关函数，如上面提到的6个函数，它是不会真正读写注册表的。

    LoadStdProfileSettings(4); // 加载标准 INI 文件选项(包括 MRU)

    InitContextMenuManager();

    InitKeyboardManager();

    InitTooltipManager();

    CMFCToolTipInfo ttParams;

    ttParams.m_bVislManagerTheme = TRUE;

    theApp.GetTooltipManager()->SetTooltipParams(AFX_TOOLTIP_TYPE_ALL,

        RUNTIME_CLASS(CMFCToolTipCtrl), &ttParams);

    // 注册应用程序的文档模板。文档模板

    // 将用作文档、框架窗口和视图之间的连接

    CSingleDocTemplate* pDocTemplate;

    pDocTemplate = new CSingleDocTemplate(

        IDR_MAINFRAME,

        RUNTIME_CLASS(CMfcDrawDoc),

        RUNTIME_CLASS(CMainFrame),       //主SDI框架窗口

        RUNTIME_CLASS(CMfcDrawView));

    if (!pDocTemplate)

        return FALSE;

    AddDocTemplate(pDocTemplate);

    // 分析标准 shell 命令、DDE、打开文件操作的命令行

    CCommandLineInfo cmdInfo;

    ParseCommandLine(cmdInfo);

    // 调度在命令行中指定的命令。如果

    // 用 /RegServer、/Register、/Unregserver 或 /Unregister 启动应用程序，则返回 FALSE。

    if (!ProcessShellCommand(cmdInfo))

        return FALSE;

    // 唯一的一个窗口已初始化，因此显示它并对其进行更新

    m_pMainWnd->ShowWindow(SW_SHOW);

    m_pMainWnd->UpdateWindow();

    // 仅当具有后缀时才调用 DragAcceptFiles

    //  在 SDI 应用程序中，这应在 ProcessShellCommand 之后发生

    return TRUE;

}

在一系列的初始化工作之后，我们new了一个CSingleDocTemplate对象，也就是申请了一块堆空间，这时将调用CSingleDocTemplate类的构造函数构造这个对象，并使pDocTemplate成为指向这块空间的指针。下面看一下CSingleDocTemplate类的构造函数做了些什么：
CSingleDocTemplate::CSingleDocTemplate(UINT nIDResource,

    CRuntimeClass* pDocClass, CRuntimeClass* pFrameClass,

    CRuntimeClass* pViewClass)

        :CDocTemplate(nIDResource, pDocClass, pFrameClass, pViewClass)

{

    m_pOnlyDoc = NULL;

}

原来是先调用了基类CDocTemplate的构造函数，将4个参数原封不动的传给了基类的构造函数，nIDResource用来表示此Document显现时应该采用的UI 对象（资源），这里我们传进来的是IDR_FRAMEWND，也就是我们的默认菜单资源的ID。而后三个就是文档，框架，视图类的CRuntimeClass指针，用于稍后的动态创建。而后将成员变量CDocument*m_pOnlyDoc初始化为NULL。

接下来看看CDocTemplate的构造函数做了什么：
CDocTemplate::CDocTemplate(UINT nIDResource, CRuntimeClass* pDocClass,

    CRuntimeClass* pFrameClass, CRuntimeClass* pViewClass)

{

    ASSERT_VALID_IDR(nIDResource);

    ASSERT(pDocClass == NULL ||

        pDocClass->IsDerivedFrom(RUNTIME_CLASS(CDocument)));

    ASSERT(pFrameClass == NULL ||

        pFrameClass->IsDerivedFrom(RUNTIME_CLASS(CFrameWnd)));

    ASSERT(pViewClass == NULL ||

        pViewClass->IsDerivedFrom(RUNTIME_CLASS(CView)));

 

    m_nIDResource = nIDResource;

    m_nIDServerResource = NULL;

    m_nIDEmbeddingResource = NULL;

    m_nIDContainerResource = NULL;

    m_nIDPreviewResource = NULL;

    m_pDocClass = pDocClass;

    m_pFrameClass = pFrameClass;

    m_pViewClass = pViewClass;

    m_pOleFrameClass = NULL;

    m_pOleViewClass = NULL;

    m_pPreviewFrameClass = NULL;

    m_pPreviewViewClass = NULL;

    m_pAttachedFactory = NULL;

    m_hMenuInPlace = NULL;

    m_hAccelInPlace = NULL;

    m_hMenuEmbedding = NULL;

    m_hAccelEmbedding = NULL;

    m_hMenuInPlaceServer = NULL;

    m_hAccelInPlaceServer = NULL;

    // add to pStaticList if constructed asstatic instead of on heap

    if (CDocManager::bStaticInit)

    {

        m_bAutoDelete = FALSE;

        if (CDocManager::pStaticList== NULL)

            CDocManager::pStaticList = newCPtrList;

        if(CDocManager::pStaticDocManager == NULL)

            CDocManager::pStaticDocManager = newCDocManager;

        CDocManager::pStaticList->AddTail(this);

    }

    else

    {

        m_bAutoDelete = TRUE;  // usually allocated on the heap

        LoadTemplate();

    }

}

在一些防御性代码之后，将4个参数赋值给4个对应的成员变量，并且判断了模板是静态构造的还是在堆上动态生成的，这里CDocManager::bStaticInit为FALSE，所以执行LoadTemplate()，它的作用是为CDocTemplate或者其衍生类加载资源。

之后执行AddDocTemplate(pDocTemplate)，将刚刚创建的文档模板指针pDocTemplate加入到CDocManager所管理的文档模板链表m_templateList中。因为我们并没有在CSDIApp中改写AddDocTemplate这个函数，所以执行的是基类的CWinApp::AddDocTemplate()。让我们看下它的定义：

void CWinApp::AddDocTemplate(CDocTemplate* pTemplate)

{

    if (m_pDocManager == NULL)

        m_pDocManager = newCDocManager;

    m_pDocManager->AddDocTemplate(pTemplate);

}

运行到这里，终于将CDocManager的对象构造出来。很明显，这个CDocManager对象的指针赋给了CWinApp的成员变量CDocManager* m_pDocManager，那么CWinApp及其子类对象就能通过这个指针来访问CDocManager类，进而获取文档模板。因此，CDocManager类是连接CWinApp及其子类与文档模板的桥梁。侯捷老师的这幅图很好的说明了这一关系。

 

作为补充，将CDocManager类的定义放在下面(appui2.cpp)：

classCDocManager : public CObject
{
　DECLARE_DYNAMIC(CDocManager)
　public:

　　// Constructor
　　CDocManager();

　　//Document functions
　　virtual void AddDocTemplate(CDocTemplate* pTemplate);
　　virtual POSITION GetFirstDocTemplatePosition() const;
　　virtual CDocTemplate*GetNextDocTemplate(POSITION& pos) const;
　　virtual void RegisterShellFileTypes(BOOL bCompat);
　　void UnregisterShellFileTypes();
　　virtual CDocument* OpenDocumentFile(LPCTSTRlpszFileName); // open named file
　　virtual BOOL SaveAllModified(); // save before exit
　　virtual void CloseAllDocuments(BOOL bEndSession); //close documents before exiting
　　virtual int GetOpenDocumentCount();

　　// helper for standard commdlg dialogs
　　virtual BOOL DoPromptFileName(CString& fileName,UINT nIDSTitle,
　　DWORD lFlags, BOOL bOpenFileDialog, CDocTemplate*pTemplate);

　　//Commands
　　// Advanced: process async DDE request
　　virtual BOOL OnDDECommand(LPTSTR lpszCommand);
　　virtual void OnFileNew();
　　virtual void OnFileOpen();

　　// Implementation
　protected:
　　CPtrList m_templateList;
　　int GetDocumentCount(); // helper to count number oftotal documents

　public:
　　static CPtrList* pStaticList; // for staticCDocTemplate objects
　　static BOOL bStaticInit; // TRUE during staticinitialization
　　static CDocManager* pStaticDocManager; // for staticCDocTemplate objects

　public:
　　virtual ~CDocManager();
　　#ifdef _DEBUG
　　　virtual void AssertValid() const;
　　　virtual void Dump(CDumpContext& dc) const;
　　#endif
};

可以看到文档模板链表m_templateList是CPtrList类型的成员变量，而看了CPtrList的定义便知，它就是一个实现链表结构的类。另外还有一些对链表进行操作的成员函数。

 

在CDocManager对象被构造出来之后，CWinApp:: AddDocTemplate调用了CDocManager::AddDocTemplate。其源代码如下：

void CDocManager::AddDocTemplate(CDocTemplate*pTemplate)

{

　if (pTemplate == NULL)

　{

　　if (pStaticList != NULL)

　　{

　　　POSITION pos =pStaticList->GetHeadPosition();

　　　while (pos != NULL)

　　　{

　　　　CDocTemplate* pTemplate =(CDocTemplate*)pStaticList->GetNext(pos);

　　　　AddDocTemplate(pTemplate);

　　　}

　　　delete pStaticList;

　　　pStaticList = NULL;

　　}

　　bStaticInit = FALSE;

　}

　else

　{

　　ASSERT_VALID(pTemplate);

　　ASSERT(m_templateList.Find(pTemplate,NULL) == NULL);// must not be in list

　　pTemplate->LoadTemplate();

　　m_templateList.AddTail(pTemplate);

　}

}

将刚刚创建的文档模板的指针pDocTemplate作为参数传进来，因为pDocTemplate不为空，那么执行的就是m_templateList.AddTail(pTemplate)，也就是将pDocTemplate加到m_templateList链表的末尾。至此，刚刚创建的文档模板就加入了文档模板链表m_templateList中，以供CDocManager类管理。

 

CCommandLineInfo cmdInfo;

ParseCommandLine(cmdInfo);

if (!ProcessShellCommand(cmdInfo))

return FALSE;

接下来到了这几条语句，咋一看不知道是做什么的，其实正是这几条语句引起了窗口的创建等一系列的动作， 可以说是重中之重。让我们来看看这两条语句究竟做了什么：

MSDN说“MFC应用一般都会在它的应用对象中使用函数InitInstance创建CCommandLineInfo类的一个本地实例。然后把该对象传给CWinApp::ParseCommandLine，ParseCommandLine又重复调用CCommandLineInfo::ParseParam（每个参数调用一次）来填充CCommandLineInfo对象。最后，CCommandLineInfo对象被传给CWinApp::ProcessShellCommand来处理命令行参数和选项。“

实际上，这几条语句也确实是这么做的。首先定义了一个CCommandLineInfo类的实例，引发该类构造函数的调用，让我们看看这个构造函数的源代码：

CCommandLineInfo::CCommandLineInfo()

{

    m_bShowSplash = TRUE;

    m_bRunEmbedded = FALSE;

    m_bRunAutomated = FALSE;

    m_bRegisterPerUser = FALSE;

    m_nShellCommand = FileNew;

}

很明显，构造函数将m_nShellCommand默认为FileNew，它就是应用程序实例的Shell命令。

而后调用ParseCommandLine，看看这个函数做了什么：

void CWinApp::ParseCommandLine(CCommandLineInfo& rCmdInfo)

{

    for (inti = 1; i < __argc; i++)

    {

        LPCTSTR pszParam = __targv[i];

        BOOL bFlag = FALSE;

        BOOL bLast = ((i + 1) == __argc);

        if (pszParam[0] == '-' || pszParam[0] == '/')

        {

            // remove flag specifier

            bFlag = TRUE;

            ++pszParam;

        }

        rCmdInfo.ParseParam(pszParam, bFlag, bLast);

    }

}

可以看出这个函数的作用是对命令行参数的处理，确实如MSDN所说，处理后的每一个命令行参数都被送到ParseParam函数中。__argc和__argv[]的功能与控制台程序中的argc与argv类似，__argc代表着命令行参数的个数，__argv[]指向命令行参数字符串，__argc至少是1，而__argv[0] 指向程序文件所在的路径。所以先将pszParam的初值设为__argv[1],也就是指向第一个参数（如果存在的话），之后遍历各个命令行参数，如果在参数开头碰到”-”与”/”这些命令标志，跳过并将bFlag置为true，因为我们需要比对的只是去除标志之后的参数。另外，当解析到最后一个命令行参数的时候，将bLast也置为true。接下来看看ParseParam函数的源代码：

void CCommandLineInfo::ParseParam(const TCHAR*pszParam,BOOL bFlag,BOOL bLast)

{

    if (bFlag)

    {

        const CStringAstrParam(pszParam);

        ParseParamFlag(strParam.GetString());

    }

    else

        ParseParamNotFlag(pszParam);

    ParseLast(bLast);

}

如果前面遇到了带标志的命令行参数，那么将新建了一个CString对象，用来储存传进来的pszParam，然后调用ParseParamFlag进行处理：

命令行参数与执行的命令对应如下：

 再看下面的程序就很清楚了，其实就是将传进来的pszParam与各种参数进行比对，判断命令参数的类型。
void CCommandLineInfo::ParseParamFlag(const char* pszParam)

{

    // OLE command switches are caseinsensitive, while

    // shell command switches are casesensitive

    if (lstrcmpA(pszParam, "pt") == 0)

        m_nShellCommand = FilePrintTo;

    else if(lstrcmpA(pszParam, "p") == 0)

        m_nShellCommand = FilePrint;

    else if(::AfxInvariantStrICmp(pszParam, "Register")== 0 ||

        ::AfxInvariantStrICmp(pszParam, "Regserver")== 0)

        m_nShellCommand = AppRegister;

    else if(::AfxInvariantStrICmp(pszParam, "RegisterPerUser")== 0 ||

        ::AfxInvariantStrICmp(pszParam, "RegserverPerUser")== 0)

    {

        m_nShellCommand = AppRegister;

        m_bRegisterPerUser = TRUE;

    }

    else if(::AfxInvariantStrICmp(pszParam, "Unregister")== 0 ||

        ::AfxInvariantStrICmp(pszParam, "Unregserver")== 0)

        m_nShellCommand = AppUnregister;

    else if(::AfxInvariantStrICmp(pszParam, "UnregisterPerUser")== 0 ||

        ::AfxInvariantStrICmp(pszParam, "UnregserverPerUser")== 0)

    {

        m_nShellCommand = AppUnregister;

        m_bRegisterPerUser = TRUE;

    }

    else if(_strnicmp(pszParam, RESTART_COMMAND_LINE_ARG, _countof(RESTART_COMMAND_LINE_ARG)- 1) == 0)

    {

        CString strParam = pszParam;

        if (strParam.GetLength() ==_countof(RESTART_COMMAND_LINE_ARG) + RESTART_IDENTIFIER_LEN)

        {

            m_nShellCommand = RestartByRestartManager;

            m_strRestartIdentifier = strParam.Right(RESTART_IDENTIFIER_LEN);

        }

    }

    else if(lstrcmpA(pszParam, "ddenoshow")== 0)

    {

        AfxOleSetUserCtrl(FALSE);

        m_nShellCommand = FileDDENoShow;

    }

    else if(lstrcmpA(pszParam, "dde") == 0)

    {

        AfxOleSetUserCtrl(FALSE);

        m_nShellCommand = FileDDE;

    }

    else if(::AfxInvariantStrICmp(pszParam, "Embedding")== 0)

    {

        AfxOleSetUserCtrl(FALSE);

        m_bRunEmbedded = TRUE;

        m_bShowSplash = FALSE;

    }

    else if(::AfxInvariantStrICmp(pszParam, "Automation")== 0)

    {

        AfxOleSetUserCtrl(FALSE);

        m_bRunAutomated = TRUE;

        m_bShowSplash = FALSE;

    }

}

 

否则调用无标志参数的解析函数：

void CCommandLineInfo::ParseParamNotFlag(constTCHAR* pszParam)

{

    if (m_strFileName.IsEmpty())

        m_strFileName = pszParam;

    else if(m_nShellCommand == FilePrintTo && m_strPrinterName.IsEmpty())

        m_strPrinterName = pszParam;

    else if(m_nShellCommand == FilePrintTo && m_strDriverName.IsEmpty())

        m_strDriverName = pszParam;

    else if(m_nShellCommand == FilePrintTo && m_strPortName.IsEmpty())

        m_strPortName = pszParam;

}

 

接着调用CCommandLineInfo::ParseLast，源代码如下：

void CCommandLineInfo::ParseLast(BOOL bLast)

{

    if (bLast)

    {

        if (m_nShellCommand ==FileNew && !m_strFileName.IsEmpty())

            m_nShellCommand = FileOpen;

        m_bShowSplash = !m_bRunEmbedded && !m_bRunAutomated;

    }

}

这个函数的作用主要是在命令行参数全部处理完毕之后，判断参数中是否包含文件名，从而区分FileNew与FileOpen命令。（也就是上面表格中的第一种与第二种情况，还记得最开始m_nShellCommand最开始就被赋值为FileNew了么，如果参数不符合ParseParamFlag中任何一种情况，那么调用ParseLast时，m_nShellCommand就依然还是FileNew）

 

最后调用ProcessShellCommand(cmdInfo)，这就是shell命令的解析函数了，看看代码便知道：

BOOL CWinApp::ProcessShellCommand(CCommandLineInfo&rCmdInfo)

{

    BOOL bResult = TRUE;

    switch (rCmdInfo.m_nShellCommand)

    {

……

    case CCommandLineInfo::FileNew:

        if(!AfxGetApp()->OnCmdMsg(ID_FILE_NEW, 0, NULL, NULL))

            OnFileNew();

        if (m_pMainWnd == NULL)

            bResult = FALSE;

        break;

……

}

这里只贴出FileNew部分的代码，很明显，这里就是分析m_nShellCommand的类型，通过OnCmdMsg函数来分发命令消息，最终由相应的命令响应函数进行响应。

还记得前面CCommandLineInfo类的构造函数中将m_nShellCommand默认赋值为FileNew了么，因为这里我们运行时，除了程序路径之外是没有命令行参数的，所以__argc就为1，CWinApp::ParseCommandLine实际上没有执行任何语句，实际起作用的只有ProcessShellCommand(cmdInfo)，所以这里m_nShellCommand就等于FileNew，但是其他带有命令行参数情况下还是要经过CWinApp::ParseCommandLine进行解析的。

 

CWinApp类响应了这个命令消息：

void CWinApp::OnFileNew()

{

    if (m_pDocManager != NULL)

        m_pDocManager->OnFileNew();

}

而它又只是简单的调用了CDocManager类中的响应函数，还记得前面说的么，m_pDocManager正是CWinApp中指向CDocManager类的指针。

继续看源码：

void CDocManager::OnFileNew()

{

    if (m_templateList.IsEmpty())

    {

        TRACE(traceAppMsg, 0, "Error:no document templates registered with CWinApp.\n");

        AfxMessageBox(AFX_IDP_FAILED_TO_CREATE_DOC);

        return;

    }

    CDocTemplate* pTemplate =(CDocTemplate*)m_templateList.GetHead();

    if (m_templateList.GetCount()> 1)

    {

        // more than one document templateto choose from

        // bring up dialog prompting user

        CNewTypeDlg dlg(&m_templateList);

        INT_PTR nID = dlg.DoModal();

        if (nID == IDOK)

            pTemplate = dlg.m_pSelectedTemplate;

        else

            return;     // none - canceloperation

    }

    ASSERT(pTemplate != NULL);

    ASSERT_KINDOF(CDocTemplate, pTemplate);

    pTemplate->OpenDocumentFile(NULL);

        // if returns NULL, the user hasalready been alerted

}

首先获得链表第一个节点的内容，也就是指向第一份文档模板的指针（至于为什么要做类型转换，是因为CPtrList类中定义链表结点DATA数据类型的时候，用的类型是void*，巧妙的实现了泛型的效果，因为MFC编写的时候template还没有成为标准。根据类型转换的不同，就成为了不同的类型）。然后判断m_templateList中的结点数，也就是相应的文档模板数，大于1说明有多个文档模板，则会生成一个模态对话框询问我们是否要选择模板。默认的话只生成了一种文档模板，所以直接调用OpenDocumentFile，因为这是个纯虚函数

virtual CDocument* OpenDocumentFile(LPCTSTR lpszPathName, BOOL bMakeVisible =TRUE) = 0;

virtual CDocument* OpenDocumentFile(LPCTSTR lpszPathName, BOOL bAddToMRU, BOOLbMakeVisible) = 0;

而子类CSingleDocTemplate重载了这个函数，所以调用的是CSingleDocTemplate::OpenDocumentFile。

源代码如下：

CDocument*CSingleDocTemplate::OpenDocumentFile(LPCTSTR lpszPathName, BOOL bMakeVisible)

{

    returnOpenDocumentFile(lpszPathName, TRUE, bMakeVisible);

}

 

CDocument*CSingleDocTemplate::OpenDocumentFile(LPCTSTR lpszPathName, BOOL bAddToMRU, BOOLbMakeVisible)

{

    CDocument* pDocument = NULL;

    CFrameWnd* pFrame = NULL;

    BOOL bCreated = FALSE;     // => doc and frame created

    BOOL bWasModified = FALSE;

    if (m_pOnlyDoc != NULL)

    {

        // already have a document - reinitit

        pDocument = m_pOnlyDoc;

        if(!pDocument->SaveModified())

        {

            // set a flag to indicate thatthe document being opened should not

            // be removed from the MRUlist, if it was being opened from there

            g_bRemoveFromMRU = FALSE;

            return NULL;        // leave theoriginal one

        }

        pFrame = (CFrameWnd*)AfxGetMainWnd();

        ASSERT(pFrame != NULL);

        ASSERT_KINDOF(CFrameWnd, pFrame);

        ASSERT_VALID(pFrame);

    }

    else

    {

        // create a new document

        pDocument = CreateNewDocument();

        ASSERT(pFrame == NULL);    // will be created below

        bCreated = TRUE;

    }

    if (pDocument == NULL)

    {

        AfxMessageBox(AFX_IDP_FAILED_TO_CREATE_DOC);

        return NULL;

    }

    ASSERT(pDocument == m_pOnlyDoc);

    if (pFrame == NULL)

    {

        ASSERT(bCreated);

 

        // create frame - set as maindocument frame

        BOOL bAutoDelete = pDocument->m_bAutoDelete;

        pDocument->m_bAutoDelete = FALSE;

                    // don't destroy ifsomething goes wrong

        pFrame = CreateNewFrame(pDocument,NULL);

        pDocument->m_bAutoDelete = bAutoDelete;

        if (pFrame == NULL)

        {

            AfxMessageBox(AFX_IDP_FAILED_TO_CREATE_DOC);

            delete pDocument;      // explicitdelete on error

            return NULL;

        }

    }

    if (lpszPathName == NULL)//调用OpenDocumentFile时传进来的实参是NULL

    {

        // create a new document

        SetDefaultTitle(pDocument);

        // avoid creating temporarycompound file when starting up invisible

        if (!bMakeVisible)

            pDocument->m_bEmbedded = TRUE;

        if (!pDocument->OnNewDocument())

        {

            // user has been alerted towhat failed in OnNewDocument

            TRACE(traceAppMsg, 0, "CDocument::OnNewDocumentreturned FALSE.\n");

            if (bCreated)

                pFrame->DestroyWindow();    // will destroydocument

            return NULL;

        }

    }

    else

    {

        CWaitCursor wait;

        // open an existing document

        bWasModified = pDocument->IsModified();

        pDocument->SetModifiedFlag(FALSE);  // not dirty foropen

        if (!pDocument->OnOpenDocument(lpszPathName))

        {

            // user has been alerted towhat failed in OnOpenDocument

            TRACE(traceAppMsg, 0, "CDocument::OnOpenDocumentreturned FALSE.\n");

            if (bCreated)

            {

                pFrame->DestroyWindow();    // will destroydocument

            }

            else if (!pDocument->IsModified())

            {

                // original document isuntouched

                pDocument->SetModifiedFlag(bWasModified);

            }

            else

            {

                // we corrupted theoriginal document

                SetDefaultTitle(pDocument);

 

                if(!pDocument->OnNewDocument())

                {

                    TRACE(traceAppMsg, 0, "Error:OnNewDocument failed after trying "

                        "to open adocument - trying to continue.\n");

                    // assume we cancontinue

                }

            }

            return NULL;        // openfailed

        }

        pDocument->SetPathName(lpszPathName, bAddToMRU);

        pDocument->OnDocumentEvent(CDocument::onAfterOpenDocument);

    }

 

    CWinThread* pThread = AfxGetThread();

    ASSERT(pThread);

    if (bCreated &&pThread->m_pMainWnd == NULL)

    {

        // set as main frame(InitialUpdateFrame will show the window)

        pThread->m_pMainWnd = pFrame;

    }

    InitialUpdateFrame(pFrame, pDocument,bMakeVisible);

    return pDocument;

}

因为m_pOnlyDoc 等于NULL，接下来调用基类的CreateNewDocument()，代码如下：

    CDocument*CDocTemplate::CreateNewDocument()

{

    // default implementation constructsone from CRuntimeClass

    if (m_pDocClass == NULL)

    {

        TRACE(traceAppMsg, 0, "Error:you must override CDocTemplate::CreateNewDocument.\n");

        ASSERT(FALSE);

        return NULL;

    }

    CDocument* pDocument =(CDocument*)m_pDocClass->CreateObject();

    if (pDocument == NULL)

    {

        TRACE(traceAppMsg, 0, "Warning:Dynamic create of document type %hs failed.\n",

            m_pDocClass->m_lpszClassName);

        return NULL;

    }

    ASSERT_KINDOF(CDocument, pDocument);

    AddDocument(pDocument);

    return pDocument;

}

这里通过m_pDocClass（不记得了？它等于文档类的CRunTimeClass指针）调用CreateObject()动态创建了文档，然后通过调用AddDocument函数使新创建的文档与文档模板产生关联。

首先调用的是子类的CSingleDocTemplate::AddDocument，

void CSingleDocTemplate::AddDocument (CDocument* pDoc)

{

    ASSERT(m_pOnlyDoc == NULL);    // one at a time please

    ASSERT_VALID(pDoc);

    CDocTemplate::AddDocument(pDoc);

    m_pOnlyDoc = pDoc;

}

里面又调用了基类的CDocTemplate::AddDocument，使创建的新文档回指其所属的文档模板。

void CDocTemplate::AddDocument(CDocument* pDoc)

{

    ASSERT_VALID(pDoc);

    ASSERT(pDoc->m_pDocTemplate == NULL);   // no templateattached yet

    pDoc->m_pDocTemplate = this;

}

最后，将m_ pOnlyDoc指向这唯一的文档。

 

接下来，继续回到CSingleDocTemplate::OpenDocumentFile执行，CreateNewFrame被调用：

CFrameWnd*CDocTemplate::CreateNewFrame(CDocument* pDoc, CFrameWnd* pOther)

{

    if (pDoc != NULL)

        ASSERT_VALID(pDoc);

    // create a frame wired to thespecified document

 

    ASSERT(m_nIDResource != 0); // musthave a resource ID to load from

    CCreateContext context;

    context.m_pCurrentFrame = pOther;

    context.m_pCurrentDoc = pDoc;

    context.m_pNewViewClass = m_pViewClass;

    context.m_pNewDocTemplate = this;

 

    if (m_pFrameClass == NULL)

    {

        TRACE(traceAppMsg, 0, "Error:you must override CDocTemplate::CreateNewFrame.\n");

        ASSERT(FALSE);

        return NULL;

    }

    CFrameWnd* pFrame = (CFrameWnd*)m_pFrameClass->CreateObject();

    if (pFrame == NULL)

    {

        TRACE(traceAppMsg, 0, "Warning:Dynamic create of frame %hs failed.\n",

            m_pFrameClass->m_lpszClassName);

        return NULL;

    }

    ASSERT_KINDOF(CFrameWnd, pFrame);

    if (context.m_pNewViewClass ==NULL)

        TRACE(traceAppMsg, 0, "Warning:creating frame with no default view.\n");

    // create new from resource

    if (!pFrame->LoadFrame(m_nIDResource,

            WS_OVERLAPPEDWINDOW |FWS_ADDTOTITLE,   // default frame styles

            NULL, &context))

    {

        TRACE(traceAppMsg, 0, "Warning:CDocTemplate couldn't create a frame.\n");

        // frame will be deleted inPostNcDestroy cleanup

        return NULL;

    }

    // it worked !

    return pFrame;

}

这里就是《深入浅出MFC 第二版》 p464的内容了，视图的创建是在框架窗口生成前（LoadFrame中）被引发的，显得比较隐晦。其中CCreateContext类就包含了创建视图时所需要的必要参数，m_pNewViewClass就是待创建视图对象的CRunTimeClass指针，用于动态创建。其余的则是与待创建视图对象所关联的文档，框架，文档模板。

同样的调用CreateObject()动态创建出框架类对象后终于到了我们熟悉的LoadFrame函数（和MDI不同，SDI程序并未重载这个函数，所以直接调用基类的）。

调用情况如下：

LoadFrame(m_nIDResource,WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE,&context);

定义如下：

BOOLCFrameWnd::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle,

    CWnd* pParentWnd, CCreateContext* pContext)

{

    // only do this once

    ASSERT_VALID_IDR(nIDResource);

    ASSERT(m_nIDHelp == 0 || m_nIDHelp == nIDResource);

 

    m_nIDHelp = nIDResource;   // ID for help context (+HID_BASE_RESOURCE)

 

    CString strFullString;

    if(strFullString.LoadString(nIDResource))

        AfxExtractSubString(m_strTitle, strFullString, 0);    // firstsub-string

    VERIFY(AfxDeferRegisterClass(AFX_WNDFRAMEORVIEW_REG));

    // attempt to create the window

    LPCTSTR lpszClass = GetIconWndClass(dwDefaultStyle,nIDResource);

    CString strTitle = m_strTitle;

    if (!Create(lpszClass,strTitle, dwDefaultStyle, rectDefault,

     pParentWnd, ATL_MAKEINTRESOURCE(nIDResource), 0L, pContext))

    {

        return FALSE;   // will selfdestruct on failure normally

    }

    // save the default menu handle

    ASSERT(m_hWnd != NULL);

    m_hMenuDefault = m_dwMenuBarState == AFX_MBS_VISIBLE ? ::GetMenu(m_hWnd) : m_hMenu;

    // load accelerator resource

    LoadAccelTable(ATL_MAKEINTRESOURCE(nIDResource));

    if (pContext == NULL)   // send initialupdate

        SendMessageToDescendants(WM_INITIALUPDATE,0, 0, TRUE, TRUE);

    return TRUE;

}

LoadFrame是个很重要的函数，窗口类的注册，创建都在这里完成，在这里面最终就能看到被层层包装的WIN32 API。首先，利用AfxDeferRegisterClass对窗口进行第一次注册，而AfxDeferRegisterClass是个宏：

#define AfxDeferRegisterClass(fClass)  AfxEndDeferRegisterClass(fClass)

实际调用的是AfxEndDeferRegisterClass：

BOOL AFXAPIAfxEndDeferRegisterClass(LONG fToRegister)

{

    // mask off all classes that arealready registered

    AFX_MODULE_STATE* pModuleState = AfxGetModuleState();

    fToRegister &= ~pModuleState->m_fRegisteredClasses;

    if (fToRegister == 0)

        return TRUE;

 

    LONG fRegisteredClasses = 0;

 

    // common initialization

    WNDCLASS wndcls;

    memset(&wndcls, 0, sizeof(WNDCLASS));  // start with NULLdefaults

    wndcls.lpfnWndProc = DefWindowProc;

    wndcls.hInstance = AfxGetInstanceHandle();

    wndcls.hCursor = afxData.hcurArrow;

 

    INITCOMMONCONTROLSEX init;

    init.dwSize = sizeof(init);

 

    // work to register classes asspecified by fToRegister, populate fRegisteredClasses as we go

    ……//省略

        if(fToRegister & AFX_WNDFRAMEORVIEW_REG)

    {

        // SDI Frame or MDI Child windowsor views - normal colors

        wndcls.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;

        wndcls.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);

        if (_AfxRegisterWithIcon(&wndcls,_afxWndFrameOrView, AFX_IDI_STD_FRAME))

            fRegisteredClasses |= AFX_WNDFRAMEORVIEW_REG;

    }

……//省略

   return (fToRegister & fRegisteredClasses) == fToRegister;

}

MFC为我们预设了许多窗口风格，这里默认的是AFX_WNDFRAMEORVIEW_REG，通过判断传进来的窗口风格，将窗口初始化为相应的风格（这里为wndcls.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW）。另外还为窗口初始化了默认消息处理程序，句柄，光标等。

初始化完成之后，调用了_AfxRegisterWithIcon：

AFX_STATIC BOOL AFXAPI_AfxRegisterWithIcon(WNDCLASS* pWndCls,

    LPCTSTR lpszClassName, UINT nIDIcon)

{

    pWndCls->lpszClassName = lpszClassName;

    HINSTANCE hInst = AfxFindResourceHandle(

        ATL_MAKEINTRESOURCE(nIDIcon), ATL_RT_GROUP_ICON);

    if ((pWndCls->hIcon =::LoadIconW(hInst, ATL_MAKEINTRESOURCEW(nIDIcon))) == NULL)

    {

        // use default icon

        pWndCls->hIcon = ::LoadIcon(NULL, IDI_APPLICATION);

    }

    return AfxRegisterClass(pWndCls);

}

可以看到这里先为窗口加载了默认图标，最后调用AfxRegisterClass，源代码如下：

BOOL AFXAPI AfxRegisterClass(WNDCLASS* lpWndClass)

{

    WNDCLASS wndcls;       

    if (AfxCtxGetClassInfo(lpWndClass->hInstance,lpWndClass->lpszClassName,

        &wndcls))

    {

        // class already registered

        return TRUE;

    }

    if (!::AfxCtxRegisterClass(lpWndClass))

    {

        TRACE(traceAppMsg, 0, _T("Can'tregister window class named %s\n"),

            lpWndClass->lpszClassName);

        return FALSE;

    }

    BOOL bRet = TRUE;

 

    if (afxContextIsDLL)

    {

        AfxLockGlobals(CRIT_REGCLASSLIST);

        TRY

        {

            // class registeredsuccessfully, add to registered list

            AFX_MODULE_STATE* pModuleState = AfxGetModuleState();

            pModuleState->m_strUnregisterList+=lpWndClass->lpszClassName;

            pModuleState->m_strUnregisterList+='\n';

        }

        CATCH_ALL(e)

        {

            AfxUnlockGlobals(CRIT_REGCLASSLIST);

            THROW_LAST();

            // Note: DELETE_EXCEPTION notrequired.

        }

        END_CATCH_ALL

        AfxUnlockGlobals(CRIT_REGCLASSLIST);

    }

    return bRet;

}

函数会先调用AfxCtxGetClassInfo判断窗口是否已经被注册，如果未注册，接着调用::AfxCtxRegisterClass(lpWndClass)，其中又会调用:: RegisterClass(lpWndClass)完成窗口注册。到了这里终于看到隐藏很深的API函数了。

接下来就要准备创建窗口了，注册完成后遇到的第一个函数是GetIconWndClass，

LPCTSTRCFrameWnd::GetIconWndClass(DWORD dwDefaultStyle, UINT nIDResource)

{

    ASSERT_VALID_IDR(nIDResource);

    HINSTANCE hInst = AfxFindResourceHandle(

        ATL_MAKEINTRESOURCE(nIDResource), ATL_RT_GROUP_ICON);

    HICON hIcon = ::LoadIconW(hInst,ATL_MAKEINTRESOURCEW(nIDResource));

    if (hIcon != NULL)

    {

        CREATESTRUCT cs;

        memset(&cs, 0, sizeof(CREATESTRUCT));

        cs.style = dwDefaultStyle;

        PreCreateWindow(cs);

            // will fill lpszClassName withdefault WNDCLASS name

            // ignore instance handle fromPreCreateWindow.

 

        WNDCLASS wndcls;

        if (cs.lpszClass != NULL&&

            AfxCtxGetClassInfo(AfxGetInstanceHandle(),cs.lpszClass, &wndcls) &&

            wndcls.hIcon != hIcon)

        {

            // register a very similarWNDCLASS

            return AfxRegisterWndClass(wndcls.style,

                wndcls.hCursor, wndcls.hbrBackground, hIcon);

        }

    }

    return NULL;        // just usethe default

}

这里首先调用了PreCreateWindow，因为CMainFrame是CFrameWndEx的子类（MFC9.0新增？），CFrameWndEx又是CFrameWnd的子类，所以调用的是CMainFrame::PreCreateWindow。这个函数主要给我们提供了一个机会，能够在窗口生成之前修改窗口的样式，sounds nice，hmm?

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)

{

        if(!CFrameWndEx::PreCreateWindow(cs) )

            return FALSE;

        // TODO: 在此处通过修改

        //  CREATESTRUCT cs 来修改窗口类或样式

        return TRUE;

}

首先，调用其基类的CFrameWndEx::PreCreateWindow，

BOOLCFrameWndEx::PreCreateWindow(CREATESTRUCT& cs)

{

    m_dockManager.Create(this);

    m_Impl.SetDockingManager(&m_dockManager);

 

    m_Impl.RestorePosition(cs);

    return CFrameWnd::PreCreateWindow(cs);

}

这里首先创建了dockManager，然后继续调用了基类的CFrameWnd::PreCreateWindow，

BOOLCFrameWnd::PreCreateWindow(CREATESTRUCT& cs)

{

    if (cs.lpszClass == NULL)

    {

        VERIFY(AfxDeferRegisterClass(AFX_WNDFRAMEORVIEW_REG));

        cs.lpszClass = _afxWndFrameOrView;  // COLOR_WINDOW background

    }

    if (cs.style &FWS_ADDTOTITLE)

        cs.style |= FWS_PREFIXTITLE;

    cs.dwExStyle |= WS_EX_CLIENTEDGE;

    return TRUE;

}

这个函数必须在创建窗口前调用，用来完成对窗口风格参数的预处理。

 

CMainFrame::PreCreateWindow调用结束回到GetIconWndClass函数，接着调用AfxCtxGetClassInfo函数重新收集cs信息（因为前面CMainFrame::PreCreateWindow中可以更改cs)，并调用AfxRegisterWndClass函数第二次注册窗口（返回lpszName并赋值给lpszClass，再将lpszClass传递给create，也就是GetIconWndClass调用结束时，lpszClass就不为空了），至此窗口才算是真正的注册完毕。

接下来就回到了LoadFrame函数，调用Create(lpszClass, strTitle, dwDefaultStyle, rectDefault,pParentWnd,ATL_MAKEINTRESOURCE(nIDResource), 0L, pContext)来创建窗口。

函数定义如下：

BOOL CFrameWnd::Create(LPCTSTR lpszClassName,

    LPCTSTR lpszWindowName,

    DWORD dwStyle,

    const RECT& rect,

    CWnd* pParentWnd,

    LPCTSTR lpszMenuName,

    DWORD dwExStyle,

    CCreateContext* pContext)

{

    HMENU hMenu = NULL;

    if (lpszMenuName != NULL)

    {

        // load in a menu that will getdestroyed when window gets destroyed

        HINSTANCE hInst = AfxFindResourceHandle(lpszMenuName,ATL_RT_MENU);

        if ((hMenu =::LoadMenu(hInst, lpszMenuName)) == NULL)

        {

            TRACE(traceAppMsg, 0, "Warning:failed to load menu for CFrameWnd.\n");

            PostNcDestroy();            //perhaps delete the C++ object

            return FALSE;

        }

    }

    m_strTitle = lpszWindowName;   // save title for later

    if (!CreateEx(dwExStyle,lpszClassName, lpszWindowName, dwStyle,

        rect.left, rect.top, rect.right -rect.left, rect.bottom - rect.top,

        pParentWnd->GetSafeHwnd(), hMenu,(LPVOID)pContext))

    {

        TRACE(traceAppMsg, 0, "Warning:failed to create CFrameWnd.\n");

        if (hMenu != NULL)

            DestroyMenu(hMenu);

        returnFALSE;

    }

    return TRUE;

}

包括从LoadFrame传递进来的4个参数UINT nIDResource, DWORDdwDefaultStyle,CWnd* pParentWnd, CCreateContext* pContext，所有的参数都在调用CFrameWnd::Create之前初始化完毕，传递给create函数。Create在调用CreateEx之前，又对参数做了一些必要的处理（如获得菜单的句柄，因为参数列表并不是完全一致），再将参数传递给了CreateEx。

CreateEx的定义如下：

BOOL CWnd::CreateEx(DWORDdwExStyle, LPCTSTR lpszClassName,

    LPCTSTR lpszWindowName, DWORD dwStyle,

    int x, inty, int nWidth, intnHeight,

    HWND hWndParent, HMENU nIDorHMenu, LPVOID lpParam)

{

    ASSERT(lpszClassName == NULL || AfxIsValidString(lpszClassName)||

        AfxIsValidAtom(lpszClassName));

    ENSURE_ARG(lpszWindowName == NULL ||AfxIsValidString(lpszWindowName));

   

    // allow modification of several commoncreate parameters

    CREATESTRUCT cs;

    cs.dwExStyle = dwExStyle;

    cs.lpszClass = lpszClassName;

    cs.lpszName = lpszWindowName;

    cs.style = dwStyle;

    cs.x = x;

    cs.y = y;

    cs.cx = nWidth;

    cs.cy = nHeight;

    cs.hwndParent = hWndParent;

    cs.hMenu = nIDorHMenu;

    cs.hInstance = AfxGetInstanceHandle();

    cs.lpCreateParams = lpParam;

    if (!PreCreateWindow(cs))

    {

        PostNcDestroy();

        return FALSE;

    }

    AfxHookWindowCreate(this);

    HWND hWnd = ::AfxCtxCreateWindowEx(cs.dwExStyle, cs.lpszClass,

            cs.lpszName, cs.style, cs.x, cs.y, cs.cx, cs.cy,

            cs.hwndParent, cs.hMenu, cs.hInstance, cs.lpCreateParams);

#ifdef _DEBUG

    if (hWnd == NULL)

    {

        TRACE(traceAppMsg, 0, "Warning:Window creation failed: GetLastError returns 0x%8.8X\n",

            GetLastError());

    }

#endif

    if (!AfxUnhookWindowCreate())

        PostNcDestroy();       // cleanup if CreateWindowEx fails too soon

    if (hWnd == NULL)

        return FALSE;

    ASSERT(hWnd == m_hWnd); // should havebeen set in send msg hook

    return TRUE;

}

首先定义了一个CREATESTRUCT结构体对象cs，并用传递进来的参数填充它，cs等会就将用来创建窗口。 接下来又一次的调用了PreCreateWindow，但是此时lpszClass已经不为空（原因前面说了），所以AfxDeferRegisterClass(AFX_WNDFRAMEORVIEW_REG)并不会被调用。之后调用AfxHookWindowCreate(this)设置钩子和过滤函数，用于替换默认的窗口过程函数，这里不细说。

最后，::AfxCtxCreateWindowEx调用::CreateWindowEx执行真正的窗口创建动作，并在函数返回前发送出WM_CREATE消息。这个消息会被系统送往窗口过程AfxWndProc处，然后经由消息映射，会首先在CMainFrame类中找到响应函数CMainFrame::OnCreate，来看看它的定义:

int CMainFrame::OnCreate(LPCREATESTRUCTlpCreateStruct)

{

    if (CFrameWndEx::OnCreate(lpCreateStruct)== -1)

        return -1;

 

    BOOL bNameValid;

    // 基于持久值设置视觉管理器和样式

    OnApplicationLook(theApp.m_nAppLook);

 

    if (!m_wndMenuBar.Create(this))

    {

        TRACE0("未能创建菜单栏\n");

        return-1;      // 未能创建

    }

 

    m_wndMenuBar.SetPaneStyle(m_wndMenuBar.GetPaneStyle()| CBRS_SIZE_DYNAMIC | CBRS_TOOLTIPS | CBRS_FLYBY);

 

    // 防止菜单栏在激活时获得焦点

    CMFCPopupMenu::SetForceMenuFocus(FALSE);

 

    if (!m_wndToolBar.CreateEx(this,TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP | CBRS_GRIPPER | CBRS_TOOLTIPS |CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||

        !m_wndToolBar.LoadToolBar(theApp.m_bHiColorIcons? IDR_MAINFRAME_256 : IDR_MAINFRAME))

    {

        TRACE0("未能创建工具栏\n");

        return -1;      // 未能创建

    }

 

    CString strToolBarName;

    bNameValid =strToolBarName.LoadString(IDS_TOOLBAR_STANDARD);

    ASSERT(bNameValid);

    m_wndToolBar.SetWindowText(strToolBarName);

 

    CString strCustomize;

    bNameValid =strCustomize.LoadString(IDS_TOOLBAR_CUSTOMIZE);

    ASSERT(bNameValid);

    m_wndToolBar.EnableCustomizeButton(TRUE,ID_VIEW_CUSTOMIZE, strCustomize);

 

    // 允许用户定义的工具栏操作:

    InitUserToolbars(NULL, uiFirstUserToolBarId,uiLastUserToolBarId);

 

    if (!m_wndStatusBar.Create(this))

    {

        TRACE0("未能创建状态栏\n");

        return -1;      // 未能创建

    }

    m_wndStatusBar.SetIndicators(indicators,sizeof(indicators)/sizeof(UINT));

 

    // TODO: 如果您不希望工具栏和菜单栏可停靠，请删除这五行

    m_wndMenuBar.EnableDocking(CBRS_ALIGN_ANY);

    m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);

    EnableDocking(CBRS_ALIGN_ANY);

    DockPane(&m_wndMenuBar);

    DockPane(&m_wndToolBar);

 

    // 启用 Visual Studio 2005 样式停靠窗口行为

    CDockingManager::SetDockingMode(DT_SMART);

    // 启用 Visual Studio 2005 样式停靠窗口自动隐藏行为

    EnableAutoHidePanes(CBRS_ALIGN_ANY);

 

    // 启用工具栏和停靠窗口菜单替换

    EnablePaneMenu(TRUE, ID_VIEW_CUSTOMIZE,strCustomize, ID_VIEW_TOOLBAR);

 

    // 启用快速(按住 Alt 拖动)工具栏自定义

    CMFCToolBar::EnableQuickCustomization();

 

    if (CMFCToolBar::GetUserImages() == NULL)

    {

        // 加载用户定义的工具栏图像

        if(m_UserImages.Load(_T(".\\UserImages.bmp")))

        {

            CMFCToolBar::SetUserImages(&m_UserImages);

        }

    }

 

    // 启用菜单个性化(最近使用的命令)

    // TODO: 定义您自己的基本命令，确保每个下拉菜单至少有一个基本命令。

    CList<UINT, UINT> lstBasicCommands;

 

    lstBasicCommands.AddTail(ID_FILE_NEW);

    lstBasicCommands.AddTail(ID_FILE_OPEN);

    lstBasicCommands.AddTail(ID_FILE_SAVE);

    lstBasicCommands.AddTail(ID_FILE_PRINT);

    lstBasicCommands.AddTail(ID_APP_EXIT);

    lstBasicCommands.AddTail(ID_EDIT_CUT);

    lstBasicCommands.AddTail(ID_EDIT_PASTE);

    lstBasicCommands.AddTail(ID_EDIT_UNDO);

    lstBasicCommands.AddTail(ID_APP_ABOUT);

    lstBasicCommands.AddTail(ID_VIEW_STATUS_BAR);

    lstBasicCommands.AddTail(ID_VIEW_TOOLBAR);

    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2003);

    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_VS_2005);

    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_BLUE);

    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_SILVER);

    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_BLACK);

    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_AQUA);

    lstBasicCommands.AddTail(ID_VIEW_APPLOOK_WINDOWS_7);

    CMFCToolBar::SetBasicCommands(lstBasicCommands);

    return 0;

}

首先调用了基类的CFrameWndEx::OnCreate，

int CFrameWndEx::OnCreate(LPCREATESTRUCT lpCreateStruct)

{

    if (CFrameWnd::OnCreate(lpCreateStruct)== -1)

        return -1;

 

    m_Impl.m_bHasBorder= (lpCreateStruct->style & WS_BORDER) != NULL;

 

    CFrameImpl::AddFrame(this);

    OnChangeVisualManager(0,0);

    return 0;

}

继续调用基类的CFrameWnd::OnCreate，

 CFrameWnd::OnCreate(LPCREATESTRUCT lpcs)

{

    ENSURE_ARG(lpcs != NULL);

    CCreateContext* pContext =(CCreateContext*)lpcs->lpCreateParams;

    return OnCreateHelper(lpcs,pContext);

}

接着OnCreateHelper(lpcs,pContext)被调用，

int CFrameWnd::OnCreateHelper(LPCREATESTRUCT lpcs, CCreateContext* pContext)

{

    if (CWnd::OnCreate(lpcs)== -1)

        return -1;

    // create special children first

    if (!OnCreateClient(lpcs,pContext))

    {

        TRACE(traceAppMsg, 0, "Failedto create client pane/view for frame.\n");

        return -1;

    }

    // post message for initial messagestring

    PostMessage(WM_SETMESSAGESTRING,AFX_IDS_IDLEMESSAGE);

    // make sure the child windows havebeen properly sized

    RecalcLayout();

    return 0;   // create ok

}

接着CWnd::OnCreate被调用，该函数需在::CreateEX前被调用，为衍生类做一些必要的初始化工作，返回为0时表示正常，为-1时表示出错，需要销毁窗口。

接下来继续调用OnCreateClient创建客户区进而引发CreateView的调用：

BOOLCFrameWnd::OnCreateClient(LPCREATESTRUCT, CCreateContext* pContext)

{

    // default create client will create aview if asked for it

    if (pContext != NULL &&pContext->m_pNewViewClass != NULL)

    {

        if (CreateView(pContext,AFX_IDW_PANE_FIRST)== NULL)

            return FALSE;

    }

    return TRUE;

}

 

CWnd*CFrameWnd::CreateView(CCreateContext* pContext, UINT nID)

{

    ASSERT(m_hWnd != NULL);

    ASSERT(::IsWindow(m_hWnd));

    ENSURE_ARG(pContext != NULL);

    ENSURE_ARG(pContext->m_pNewViewClass != NULL);

    // Note: can be a CWnd withPostNcDestroy self cleanup

    CWnd* pView =(CWnd*)pContext->m_pNewViewClass->CreateObject();

    if (pView == NULL)

    {

        TRACE(traceAppMsg, 0, "Warning:Dynamic create of view type %hs failed.\n",

            pContext->m_pNewViewClass->m_lpszClassName);

        return NULL;

    }

    ASSERT_KINDOF(CWnd, pView);

    // views are always created with aborder!

    if (!pView->Create(NULL,NULL, AFX_WS_DEFAULT_VIEW,

        CRect(0,0,0,0), this, nID, pContext))

    {

        TRACE(traceAppMsg, 0, "Warning:could not create view for frame.\n");

        return NULL;        // can'tcontinue without a view

    }

    if (pView->GetExStyle() &WS_EX_CLIENTEDGE)

    {

        // remove the 3d style from theframe, since the view is

        // providing it.

        // make sure to recalc thenon-client area

        ModifyStyleEx(WS_EX_CLIENTEDGE, 0, SWP_FRAMECHANGED);

    }

    return pView;

}

可以看到，在CreateView中，有一句视图对象先被动态创建出来了。而后通过pView调用Create创建视图窗口，创建过程与创建框架窗口类似，CView::Create-->CWnd:: Create-->CWnd::CreateEx--> ::AfxCtxCreateWindowEx-->::CreateWindowEx,同时发出WM_CREATE消息，这里在CView类中响应了这个消息，引发CView::OnCreate的调用

int CView::OnCreate(LPCREATESTRUCT lpcs)

{

    if (CWnd::OnCreate(lpcs) == -1)

        return -1;

    // if ok, wire in the current document

    ASSERT(m_pDocument == NULL);

    CCreateContext* pContext =(CCreateContext*)lpcs->lpCreateParams;

    // A view should be created in a givencontext!

    if (pContext != NULL &&pContext->m_pCurrentDoc != NULL)

    {

        pContext->m_pCurrentDoc->AddView(this);

        ASSERT(m_pDocument != NULL);

    }

    else

    {

        TRACE(traceAppMsg, 0, "Warning:Creating a pane with no CDocument.\n");

    }

    return 0;   // ok

}

这里主要是调用了AddView将行创建的CView对象指针pView加入到CDocument类的m_viewList中，另一方面又让CView对象回指其所属的文档。m_viewList类似于m_templateList，是由文档类管理的视类对象链表。这样就建立起了两者之间的联系。

void CDocument::AddView(CView* pView)

{

    ASSERT_VALID(pView);

    ASSERT(pView->m_pDocument == NULL); //must not be already attached

    ASSERT(m_viewList.Find(pView, NULL) == NULL);   // must not be inlist

    m_viewList.AddTail(pView);

    ASSERT(pView->m_pDocument == NULL); //must be un-attached

    pView->m_pDocument = this;

    OnChangedViewList();    // must be thelast thing done to the document

}

最后调用OnChangedViewList用来完成m_viewList发生变动之后的工作，如果m_viewList为空，则删除文档。并且更新框架数。

之后回到OnCreateHelper中，发送消息让框架显示信息，最后调用RecalcLayout()。

函数声明如下：

virtual void RecalcLayout(BOOL bNotify =TRUE );

可以看到默认的参数为true，并且CView中没有重载这个函数，最终调用的是CFrameWnd::RecalcLayout。根据MSDN，当框架窗口的外观发生改变时，这个函数会被用来控制control bars（也就是状态栏，工具栏等的总称）的行为与外观（具体来说是调用CWnd：：RepositionBars函数来重新摆放control bars），并且当bNotify参数为true时，controlbars将会接收通知消息。

至此，CFrameWnd::OnCreate的调用过程结束，回到CFrameWndEX::OnCreate中，先后调用AddFrame(this)与OnChangeVisualManager(0, 0)之后返回到CMainFrame::OnCreate中，

调用m_wndMenuBar.Create创建菜单栏，并调用m_wndMenuBar.SetPaneStyle设置菜单栏窗格样式。m_wndToolBar.CreateEx和m_wndToolBar.LoadToolBar创建或者加载现有工具栏资源，并为其设定好名称。而后调用m_wndStatusBar.Create创建状态栏。而后调用m_wndStatusBar.SetIndicators(indicators,sizeof(indicators)/sizeof(UINT));来设置状态栏指示器，也就在我们程序右下角状态栏的显示。indicators参数就是状态栏指示器数组的地址，如果我们想要改变状态栏的显示，就应该改变indicators的数组成员。

static UINTindicators[] =

{

    ID_SEPARATOR,           // 状态行指示器

    ID_INDICATOR_CAPS,

    ID_INDICATOR_NUM,

    ID_INDICATOR_SCRL,

};

剩下的那些函数的功能，注释已经说得很清楚了，这里不再赘述。

至此，CMainFrame::OnCreate函数的调用过程就结束了，同时Create函数也将返回，回到Loadframe函数继续执行。在调用CFrameWnd::LoadAccelTable加载加速键表之后，调用SendMessageToDescendants(WM_INITIALUPDATE, 0, 0, TRUE, TRUE)给子窗口发送WM_INITIALUPDATE消息，CView类将响应这个消息用来完成窗口内容的初始化工作（如设置为重绘区域，清除背景）。

void CView::OnInitialUpdate()

{

    OnUpdate(NULL, 0, NULL);       //initial update

}

void CView::OnUpdate(CView* pSender, LPARAM/*lHint*/,CObject*/*pHint*/)

{

    ASSERT(pSender != this);

    UNUSED(pSender);     // unused in release builds

 

    // invalidate the entire pane, erasebackground too

    Invalidate(TRUE);

}

Loadframe函数的调用过程终于结束，回到CreateNewFrame函数中，在返回框架对象的指针之后，又回到了OpenDocumentFile函数继续执行。因为调用OpenDocumentFile时传进来的实参是NULL，所以lpszPathName等于NULL，接下来调用

pDocument->OnNewDocument(lpszPathName)，定义如下：

BOOLCDocument::OnNewDocument()

{

#ifdef _DEBUG

    if(IsModified())

        TRACE(traceAppMsg, 0, "Warning:OnNewDocument replaces an unsaved document.\n");

#endif

    DeleteContents();

    m_strPathName.Empty();     // no path name yet

    SetModifiedFlag(FALSE);    // make clean

    OnDocumentEvent(onAfterNewDocument);

    return TRUE;

}

这里是对文档对象做一些初始化工作（如清空内容与路径名等），最后调用了OnDocumentEvent函数，用于处理文档事件，这里处理的是新建文档产生的事件。根据MSDN，调用这个函数的原因主要是文档事件会对CDocument之外的类也产生影响，需要在这个函数中进行处理。

 

接下来调用InitialUpdateFrame(pFrame,pDocument, bMakeVisible)对框架窗口内容也进行必要的初始化，函数定义如下：

voidCDocTemplate::InitialUpdateFrame(CFrameWnd* pFrame, CDocument* pDoc,BOOLbMakeVisible)

{

       // just delagate to implementation inCFrameWnd

       pFrame->InitialUpdateFrame(pDoc,bMakeVisible);

}

而CDocTemplate::InitialUpdateFrame只是简单调用了其基类的

void CFrameWnd::InitialUpdateFrame(CDocument* pDoc, BOOL bMakeVisible)

{

    // if the frame does not have an activeview, set to first pane

    CView* pView = NULL;

    if (GetActiveView()== NULL)

    {

        CWnd* pWnd = GetDescendantWindow(AFX_IDW_PANE_FIRST,TRUE);

        if (pWnd != NULL &&pWnd->IsKindOf(RUNTIME_CLASS(CView)))

        {

            pView = (CView*)pWnd;

            SetActiveView(pView, FALSE);

        }

    }

    if (bMakeVisible)

    {

        // send initial update to all views(and other controls) in the frame

        SendMessageToDescendants(WM_INITIALUPDATE,0, 0, TRUE, TRUE);

        // give view a chance to save thefocus (CFormView needs this)

        if (pView != NULL)

            pView->OnActivateFrame(WA_INACTIVE,this);

        // finally, activate the frame

        // (send the default show commandunless the main desktop window)

        int nCmdShow = -1;      // default

        CWinApp* pApp = AfxGetApp();

        if (pApp != NULL &&pApp->m_pMainWnd == this)//仅单窗口程序执行

        {

            nCmdShow = pApp->m_nCmdShow; //use the parameter from WinMain

            pApp->m_nCmdShow = -1; // set todefault after first time

        }

        ActivateFrame(nCmdShow);

        if (pView != NULL)

            pView->OnActivateView(TRUE,pView, pView);

    }

    // update frame counts and frame title(may already have been visible)

    if (pDoc != NULL)

        pDoc->UpdateFrameCounts();

    OnUpdateFrameTitle(TRUE);

}

    return pDocument;

首先调用GetActiveView()获取当前的活动视图，如果没有则调用GetDescendantWindow(AFX_IDW_PANE_FIRST,TRUE)获取子窗口，也就是视图窗口的指针，再调用SetActiveView将其设置为活动视图。bMakeVisible默认等于true，接下来再次调用SendMessageToDescendants初始化所有框架中的视图窗口。当框架中有视图窗口被激活或者取消激活时，CView::OnActivateFrame会被框架类调用。CView::OnActivateFrame本身是个空函数，但是可以在子类中重载它，以完成自己所需要的操作，这里我们并没有重载它。接下来将主框架指针m_pMainWnd设置为pFrame（单窗口程序），最后终于要正式激活框架窗口了，调用ActivateFrame函数激活框架窗口，

void CFrameWnd::ActivateFrame(int nCmdShow)

    // nCmdShow is the normal show modethis frame should be in

{

    // translate default nCmdShow (-1)

    if (nCmdShow == -1)

    {

        if (!IsWindowVisible())

            nCmdShow = SW_SHOWNORMAL;

        else if(IsIconic())

            nCmdShow = SW_RESTORE;

    }

    // bring to top before showing

    BringToTop(nCmdShow);

    if (nCmdShow != -1)//单文档程序才会执行

    {

        // show the window as specified

        ShowWindow(nCmdShow);

        // and finally, bring to top aftershowing

        BringToTop(nCmdShow);

    }

}

nCmdShow是WinMain的参数之一，指明了窗口将被如何显示，初始时为1，1代表的就是SW_SHOWNORMAL，（单文档程序和多文档程序在这里有所不同，单文档程序会执行标红的那两段，因为m_nCmdShow等于1，所以单文档程序中的nCmdShow被赋值为-1后又被重置为1。而多文档程序中nCmdShow等于-1，-1并不是nCmdShow可用的取值，至于为什么要弄得这么麻烦，主要是为了在多窗口程序中，能够适用于激活显示和从最小化恢复这两种情况，最终还是会将nCmdShow赋值为SW_SHOWNORMAL（=1）或SW_RESTORE（=9））然后会两次调用BringToTop函数（显示前和显示后）将框架窗口置于Z-Order的顶端（当然最终调用的是大家熟悉的:: BringWindowToTop，这里就不放源码了）。

接下来OnActivateView(TRUE,pView, pView)被调用，将焦点设置为被激活的视图。

void CView::OnActivateView(BOOLbActivate, CView* pActivateView, CView*)

{

    UNUSED(pActivateView);   // unused inrelease builds

    if (bActivate)

    {

        ASSERT(pActivateView== this);

        // take the focus if this frame/view/pane is now active

        if (IsTopParentActive())

            SetFocus();

    }

}

最后调用OnUpdateFrameTitle为框架更新标题栏。最后的最后返回pDocument，代表OpenDocumentFile函数调用过程的结束。至此，框架/文档/视图都已经被构建出来，并做好了显示前的一切准备工作。

 

终于我们回到了InitInstance函数中，剩下就是对窗口的显示和更新

m_pMainWnd->ShowWindow(SW_SHOW);

m_pMainWnd->UpdateWindow();//送出WM_PAINT消息

当然对于单文档程序来说，前面我们已经调用了一次ShowWindow显示了窗口，只是未更新。

而后返回true，结束InitInstance的调用过程。

2.1.4Run()的调用

结束了InitInstance的调用过程，我们终于回到了AfxWinMain函数中，最后就是调用Run()建立消息循环。来看看具体的定义，

int CWinApp::Run()

{

    if (m_pMainWnd == NULL &&AfxOleGetUserCtrl())

    {

        // Not launched /Embedding or /Automation, but has no mainwindow!

        TRACE(traceAppMsg,0, "Warning: m_pMainWnd is NULL inCWinApp::Run - quitting application.\n");

        AfxPostQuitMessage(0);

    }

    return CWinThread::Run();

}

可以看到里面又调用了CWinThread::Run()，

int CWinThread::Run()

{

    ASSERT_VALID(this);

    _AFX_THREAD_STATE*pState = AfxGetThreadState();

    // for tracking the idle time state

    BOOL bIdle =TRUE;

    LONG lIdleCount= 0;

    // acquire and dispatch messages until a WM_QUIT message isreceived.

    for (;;)

    {

        // phase1: check to see if we can do idle work

        while (bIdle &&

            !::PeekMessage(&(pState->m_msgCur), NULL, NULL, NULL,PM_NOREMOVE))

        {

            // call OnIdle while in bIdle state

            if (!OnIdle(lIdleCount++))

                bIdle= FALSE; // assume "no idle" state

        }

        // phase2: pump messages while available

        do

        {

            // pump message, but quit on WM_QUIT

            if (!PumpMessage())

                return ExitInstance();

            // reset "no idle" state after pumping"normal" message

            //if (IsIdleMessage(&m_msgCur))

            if (IsIdleMessage(&(pState->m_msgCur)))

            {

                bIdle = TRUE;

                lIdleCount= 0;

            }

        } while (::PeekMessage(&(pState->m_msgCur),NULL, NULL, NULL, PM_NOREMOVE));

    }

}

在接收到WM_QUIT消息之前，Run()会一直执行，进行消息的接收和发送。::PeekMessage在这里被用来查看线程消息队列中是否存在消息（虽然它也取出消息，但它并不等待消息，而是在消息不存在时返回0，消息存在时返回非0值，并且这里最后一个参数被设置为PM_NOREMOVE，也就是不从消息队列删除取到的消息，这也是为了等下::GetMessage再次取出该消息）如果空闲处理标志不为0而且在消息队列中没有消息的时候，会进行空闲时处理（当需要空闲处理时，我们应当重载OnIdle函数，并且在不需要更多空闲处理时间的时候，应当返回0，这时bIdle标志也就被置为FALSE）。如果从消息队列中接收到了消息，就会调用PumpMessage函数进行处理，

BOOL CWinThread::PumpMessage()

{

  return AfxInternalPumpMessage();

}

可以看到PumpMessage只是简单的调用了AfxInternalPumpMessage函数，

BOOL AFXAPI AfxInternalPumpMessage()

{

    _AFX_THREAD_STATE*pState = AfxGetThreadState();

 

    if (!::GetMessage(&(pState->m_msgCur),NULL, NULL, NULL))

    {

#ifdef _DEBUG

        TRACE(traceAppMsg,1, "CWinThread::PumpMessage - ReceivedWM_QUIT.\n");

            pState->m_nDisablePumpCount++;// application must die

#endif

        // Note: prevents calling message loop things in'ExitInstance'

        // will never be decremented

        return FALSE;

    }

#ifdef _DEBUG

  if (pState->m_nDisablePumpCount != 0)

    {

      TRACE(traceAppMsg, 0, "Error: CWinThread::PumpMessage called when notpermitted.\n");

      ASSERT(FALSE);

    }

#endif

#ifdef _DEBUG

    _AfxTraceMsg(_T("PumpMessage"),&(pState->m_msgCur));

#endif

  // process this message

    if (pState->m_msgCur.message != WM_KICKIDLE&& !AfxPreTranslateMessage(&(pState->m_msgCur)))

    {

        ::TranslateMessage(&(pState->m_msgCur));

        ::DispatchMessage(&(pState->m_msgCur));

    }

  return TRUE;

}

 

除去一些调试代码，可以看到这里面先调用了::GetMessage再次取出消息（要记住是在确定有消息后才会调用::GetMessage，所以并不会造成什么负担），并判断是否是WM_QUIT。如果是WM_QUIT会返回0，从而引发ExitInstance()的调用结束整个程序。如果是其他的消息，则会调用::TranslateMessage与::DispatchMessage，对消息进行翻译与发送，送往消息处理函数处。

最后我们来看看ExitInstance()做了些什么，

int CSDIApp::ExitInstance()

{

    //TODO: 处理可能已添加的附加资源

    AfxOleTerm(FALSE);

    return CWinAppEx::ExitInstance();

}

向导生成的程序帮我们重载了这个函数，我们可以在这里做一些额外的动作，或是处理已添加的附加资源。看以看到里面调用了CWinAppEx::ExitInstance()，

int CWinAppEx::ExitInstance()

{

    ControlBarCleanUp();

    return CWinApp::ExitInstance();

}

在清除了ControlBars之后又调用了CWinApp::ExitInstance()，

int CWinApp::ExitInstance()

{

    // if we remember that we're unregistering,

    // don't save our profile settings

    if (m_pCmdInfo == NULL ||

        (m_pCmdInfo->m_nShellCommand!= CCommandLineInfo::AppUnregister &&

         m_pCmdInfo->m_nShellCommand !=CCommandLineInfo::AppRegister))

    {

        if (!afxContextIsDLL)

            SaveStdProfileSettings();

    }

    // Cleanup DAO if necessary

    if (m_lpfnDaoTerm != NULL)

    {

        // If a DLL, YOU must call AfxDaoTerm prior to ExitInstance

        ASSERT(!afxContextIsDLL);

        (*m_lpfnDaoTerm)();

    }

    if (m_hLangResourceDLL != NULL)

    {

        ::FreeLibrary(m_hLangResourceDLL);

        m_hLangResourceDLL= NULL;

    }

    int nReturnValue=0;

    if(AfxGetCurrentMessage())

    {

        nReturnValue=static_cast<int>(AfxGetCurrentMessage()->wParam);

    }

    return nReturnValue; //returns the value from PostQuitMessage

}

可以看到这里主要是调用::FreeLibrary来释放加载的DLLs，并在最后调用AfxGetCurrentMessage()，获得WM_QUIT消息的wParam,也就是退出码，赋值给nReturnValue。再将其返回，赋值给nReturnCode。

 

2.1.5 AfxWinTerm()的调用

获得nReturnCode之后，调用了AfxWinTerm()，

void AFXAPI AfxWinTerm(void)

{  

    AfxUnregisterWndClasses();

    // cleanup OLE if required

    CWinThread*pThread = AfxGetApp();

    if (pThread != NULL &&pThread->m_lpfnOleTermOrFreeLib != NULL)

        (*pThread->m_lpfnOleTermOrFreeLib)(TRUE,FALSE);

    // cleanup thread local tooltip window

    AFX_MODULE_THREAD_STATE*pModuleThreadState = AfxGetModuleThreadState();

    if (pModuleThreadState->m_pToolTip != NULL)

    {

        if(pModuleThreadState->m_pToolTip->DestroyToolTipCtrl())

            pModuleThreadState->m_pToolTip= NULL;

    }

    _AFX_THREAD_STATE*pThreadState = AfxGetThreadState();

    if (!afxContextIsDLL)

    {

        // unhook windows hooks

        if (pThreadState->m_hHookOldMsgFilter != NULL)

        {

            ::UnhookWindowsHookEx(pThreadState->m_hHookOldMsgFilter);

            pThreadState->m_hHookOldMsgFilter= NULL;

        }

        if (pThreadState->m_hHookOldCbtFilter != NULL)

        {

            ::UnhookWindowsHookEx(pThreadState->m_hHookOldCbtFilter);

            pThreadState->m_hHookOldCbtFilter= NULL;

        }

    }

    // We used to suppress all exceptions here. But that's thewrong thing

    // to do. If this process crashes, we should allow Windowsto crash

    // the process and invoke watson.

}

可以看到这里依然是为程序的结束做一些清除工作，如卸载钩子等。值得注意的是最后由微软人员所作的注释，这个函数确实和老版本发生了一些变化，部分防御代码不再存在。原因正是他们所说的，在这里处理所有的意外是不对的做法，应当允许windows使进程崩溃并启用watson进行调试。

最后返回nReturnCode，结束WinMain函数的调用回到WinMainCRTStartup中。nReturnCode被传递给mainret，WinMainCRTStartup调用exit(mainret)或_c_exit()完成一些清理工作（如清理缓存，调用doexit完成全局对象的析构等），至于exit和_c_exit的区别可以参考MSDN（主要是会不会调用自动对象和临时对象的析构函数），最后返回mainret

给操作系统，由操作系统调用API函数::ExitProcess结束进程。

至此，我们的程序算是彻底结束了。