MFC内部机制探秘 / 憋错料

由于MFC应用程序涵盖了基于SDK的windows程序几乎所有的功能，所以使用MFC AppWizard创建的MFC程序将自动具有WIndows程序的基本功能，我们今天就来探寻一下MFC的框架机制。

首先大家先利用向导制动建立一个基于MFC的单文档应用程序。我取名为MFC_DISCOVER，方便大家自己验证自己的程序。

1.声明全局对象

利用应用程序对象theApp启动应用程序，theApp一般在应用程序类的实现文件中声明，而且为全局对象。在类视图点击CMFC_DISCOVERApp，再点击下面的构造成员函数，

然后在函数对应编辑框中会找到这样一句话：

声明该类的变量显然会调用该类的构造函数，构造函数就在声明该变量的上面，但是我们知道CMFC_DISCOVER类派生于CWinApp类，所以会先调用基类的构造函数，

点击上图中的CWinApp类右键，点击“转到定义”，可以查看到CWinApp类的构造函数

// Constructor
    explicit CWinApp(LPCTSTR lpszAppName = NULL);

然而我们发现该类依然有派生类CWinThread，继续按照上面做发现有这样的关系：

CObeject->CCmdTarget->CWinTread

我就不一一截图了，我们知道是在这个过程中进入WinMain函数的，那么WinMain在哪儿呢？

我们在项目管理搜索栏目里面输入WinMain，搜索如下：

在tchar.h文件中发现有这样一个定义，也就是说_tWinMain就是WinMain,现在我们需要找到_tWinMain函数。不要设断点，直接按F10键，我们就看到了_tWinMain函数了：

这个函数在MFC的源文件appmodul.cpp中，那这个main怎么被MFC调用的呢？你看那注释,是linkage to this module,也就是被链接器去调用的.准确说是被C-Runtime DLL,C运行时动态链接库调用的.

我们知道在MFC中能从代码里看到的入口点是定义一个全局的继承于CWinApp的类.这样定义下.在C++中全局变量是先于main被执行的,所以先初始化theApp后才接着调用main，WinMain里面又调用了AfxWinMain函数

2.AfxWinMain

要查看AFxWinMain函数的源码，就需要一步你的安装目录下啦，找到安装目录->vc98->MFC->Src(MFC的部分源代码) 搜索 WinMain，然后打开，就会有下面的代码（不要改动这个代码）

int AFXAPI AfxWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    _In_ LPTSTR lpCmdLine, int nCmdShow)
{
    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())//调用******InitIncetance函数**********
    {
        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 AfxLockTempMap calls
    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函数中，通过InitInstance函数完成吧了对窗口的创建步骤：设计窗口类，注册窗口类，创建窗口，显示窗口，更新窗口，消息循环，以及窗口函数等。

**根据多态性原理，AfxWinMain函数实际上是调用CMFC_DISCOVERApp的InitInstance函数来完成应用程序的一些初始化工作，包括窗口类的注册，创建，显示和更新等。

InitInstance函数代码如下：

BOOL CMFC_DISCOVERApp::InitInstance()
{
    // 如果一个运行在 Windows XP 上的应用程序清单指定要
    // 使用 ComCtl32.dll 版本 6 或更高版本来启用可视化方式，
    //则需要 InitCommonControlsEx()。否则，将无法创建窗口。
    INITCOMMONCONTROLSEX InitCtrls;
    InitCtrls.dwSize = sizeof(InitCtrls);
    // 将它设置为包括所有要在应用程序中使用的
    // 公共控件类。
    InitCtrls.dwICC = ICC_WIN95_CLASSES;
    InitCommonControlsEx(&InitCtrls);

    CWinApp::InitInstance();

    // 初始化 OLE 库
    if (!AfxOleInit())
    {
        AfxMessageBox(IDP_OLE_INIT_FAILED);
        return FALSE;
    }

    AfxEnableControlContainer();

    EnableTaskbarInteraction(FALSE);

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

    // 标准初始化
    // 如果未使用这些功能并希望减小
    // 最终可执行文件的大小，则应移除下列
    // 不需要的特定初始化例程
    // 更改用于存储设置的注册表项
    // TODO: 应适当修改该字符串，
    // 例如修改为公司或组织名
    SetRegistryKey(_T("应用程序向导生成的本地应用程序"));
    LoadStdProfileSettings(4);  // 加载标准 INI 文件选项(包括 MRU)

    // 注册应用程序的文档模板。文档模板
    // 将用作文档、框架窗口和视图之间的连接
    CSingleDocTemplate* pDocTemplate;
    pDocTemplate = new CSingleDocTemplate(
        IDR_MAINFRAME,
        RUNTIME_CLASS(CMFC_DISCOVERDoc),
        RUNTIME_CLASS(CMainFrame),       // 主 SDI 框架窗口
        RUNTIME_CLASS(CMFC_DISCOVERView));
    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();
    return TRUE;
}

不需要用完全看完，注意到在上面的代码中有这句：

if (!ProcessShellCommand(cmdInfo))
        return FALSE;

程序会通过上面的代码调用CMainFram::LoadFrame函数进行注册和创建窗口。

3.LoadFrame

该函数具体代码如下：


BOOL CFrameWnd::LoadFrame(UNIT nIDResource, DWORD dwDefaultStyle, CWnd* pParentWnd, CCreateContext* pContext)
{
/*主窗口的菜单、图标、加速键、及标题都以nIDResource标识。除创建窗口外，还要做许多工作，如设置帮助上下文ID、装入加速键、初始化子窗口。所以在文档/视图框架程序中，总是使用LoadFrame()创建主窗口。*/
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); //取得窗口标题
VERIFY(AfxDeferRegisterClass(AFX_WNDFRAMEORVIEW_REG));//**装入图标，注册窗口类**
LPCTSTR lpszClass = GetIconWndClass(dwDefaultStyle, nIDResource);
LPCTSTR lpszTitle = m_strTitle;//调用CFrameWnd::Create()
if (!Create(lpszClass, lpszTitle, dwDefaultStyle, rectDefault, pParentWnd, MAKEINTRESOURCE(nIDResource), 0L, pContext))//**创建窗口**
return FALSE;//存储菜单句柄
ASSERT(m_hWnd != NULL);
m_hMenuDefault = ::GetMenu(m_hWnd);//装入加速键
LoadAccelTable(MAKEINTRESOURCE(nIDResource));
if (pContext == NULL) //初始化子窗口
SendMessageToDescendants(WM_INITIALUPDATE, 0, 0, TRUE, TRUE);
return TRUE;
}

在上面的代码中，首先通过AfxEndDeferRegisterClass函数实现窗口注册，再调用Create函数实现窗口创建。该函数定义如下：

BOOL CFrameWnd::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, LPCTSTR lpszMenuName, DWORD dwExStyle, CCreateContext* pContext)
{
/*可见，参数列表与CWnd::Create()稍有不同。因为目的是创建主窗口，所以第6个参数要求菜单资源名*/
HMENU hMenu = NULL;
if (lpszMenuName != NULL)
{
//搜索包含该菜单资源的实例（当前进程或者按进行装入的DLL）
HINSTANCE hInst = AfxFindResourceHandl(lpszMenuName, RT_MENU);
//装入菜单资源
if ((hMenu = ::LoadMenu(hInst, lpszMenuName)) == NULL)
{
TRACE0(“Warning: failed to load menu for CFrameWnd.\n”);
PostNcDestroy(); //perhaps delete to C++ object
return FALSE;
}
}
m_strTitle = lpszWindowName; //存储窗口标题，以备后用（如刷新显示）
// 调用CWnd::CreateEx()
if (!CreateEx(dwExStyle, lpszClassName, lpszWindowName, dwStyle, rect.left, rect.top, rect.right – rect.left, rect,bottom – rect.top, pParentWnd->GetSafeHwnd(), hMenu, (LPVOID)pContext))
{
if (hMenu != NULL)
DestroyMenu(hMenu); //如果创建失败，释放菜单资源
return FALSE;
}
return TRUE;
}

其中又调用了CreateEx函数来完成实际的创建工作，

4.CreateEx

BOOL CWnd::CreateEx(DWORD dwExStyle, LPCTSTR lpszClassName,
 LPCTSTR lpszWindowName, DWORD dwStyle,
 int x, int y, int nWidth, int nHeight,
 HWND hWndParent, HMENU nIDorHMenu, LPVOID lpParam)
{
 // allow modification of several common create 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 = ::CreateWindowEx(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)
 {
  TRACE1("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 have been set in send msg hook
 return TRUE;
}

我们知道创建窗口、显示窗口是需要响应WM_PAINT消息的，也就是调用窗口函数，从上面的代码，我们看不出调用了DefWindowProc函数的代码，它是隐藏在AfxHookWindowCreate函数之中，该函数源码如下：

void AFXAPI AfxHookWindowCreate(CWnd* pWnd)
{
_AFX_THREAD_STATE* pThreadState = _afxThreadState.GetData();
if (pThreadState->m_pWndInit == pWnd)
   return;

if (pThreadState->m_hHookOldCbtFilter == NULL)
{
   pThreadState->m_hHookOldCbtFilter = ::SetWindowsHookEx(WH_CBT,//设置CBT钩子
    _AfxCbtFilterHook/*回调函数*/, NULL, ::GetCurrentThreadId());
   if (pThreadState->m_hHookOldCbtFilter == NULL)
    AfxThrowMemoryException();
}
ASSERT(pThreadState->m_hHookOldCbtFilter != NULL);
ASSERT(pWnd != NULL);
ASSERT(pWnd->m_hWnd == NULL);   // only do once

ASSERT(pThreadState->m_pWndInit == NULL);   // hook not already in progress
pThreadState->m_pWndInit = pWnd;
}

在CreateEX源码中我们看到AfxHookWindowCreate函数是先于CreatWindowEx函数被调用的，CreateWindowEx是创建真正的窗口对象函数，AfxHookWindowCreate调用了SetWindowHookEx函数设置了钩子，这样有满足设置的消息时，系统就发送给设置函数。这样每次创建窗口时，该函数就将窗口函数修改为AfxWinProc函数，这是消息循环的起点。

这里我们发现创建了一个CBT钩子,回调函数为_AfxCbtFilterHook,这个函数有点长,我们来看一下（看有注释的地方即可）

LRESULT CALLBACK
_AfxCbtFilterHook(int code, WPARAM wParam, LPARAM lParam)
{
_AFX_THREAD_STATE* pThreadState = _afxThreadState.GetData();
if (code != HCBT_CREATEWND)//专门用来钩创建窗口的钩子
{
   // wait for HCBT_CREATEWND just pass others on...
   return CallNextHookEx(pThreadState->m_hHookOldCbtFilter, code,
    wParam, lParam);
}

ASSERT(lParam != NULL);
LPCREATESTRUCT lpcs = ((LPCBT_CREATEWND)lParam)->lpcs;
ASSERT(lpcs != NULL);

CWnd* pWndInit = pThreadState->m_pWndInit;
BOOL bContextIsDLL = afxContextIsDLL;
if (pWndInit != NULL || (!(lpcs->style & WS_CHILD) && !bContextIsDLL))
{
   // Note: special check to avoid subclassing the IME window
   if (_afxDBCS)
   {
    // check for cheap CS_IME style first...
    if (GetClassLong((HWND)wParam, GCL_STYLE) & CS_IME)
     goto lCallNextHook;

    // get class name of the window that is being created
    LPCTSTR pszClassName;
    TCHAR szClassName[_countof("ime")+1];
    if (DWORD_PTR(lpcs->lpszClass) > 0xffff)
    {
     pszClassName = lpcs->lpszClass;
    }
    else
    {
     szClassName[0] = ‘\0‘;
     GlobalGetAtomName((ATOM)lpcs->lpszClass, szClassName, _countof(szClassName));
     pszClassName = szClassName;
    }

    // a little more expensive to test this way, but necessary...
    if (::AfxInvariantStrICmp(pszClassName, _T("ime")) == 0)
     goto lCallNextHook;
   }

   ASSERT(wParam != NULL); // should be non-NULL HWND
   HWND hWnd = (HWND)wParam;
   WNDPROC oldWndProc;//用于保存原window回调函数
   if (pWndInit != NULL)
   {
    AFX_MANAGE_STATE(pWndInit->m_pModuleState);

    // the window should not be in the permanent map at this time
    ASSERT(CWnd::FromHandlePermanent(hWnd) == NULL);

    // connect the HWND to pWndInit...
    pWndInit->Attach(hWnd);
    // allow other subclassing to occur first
    pWndInit->PreSubclassWindow();

    WNDPROC *pOldWndProc = pWndInit->GetSuperWndProcAddr();
    ASSERT(pOldWndProc != NULL);

    // subclass the window with standard AfxWndProc
    WNDPROC afxWndProc = AfxGetAfxWndProc();
    oldWndProc = (WNDPROC)SetWindowLongPtr(hWnd, GWLP_WNDPROC,
     (DWORD_PTR)afxWndProc);//设置新的回调函数afxWndProc
    ASSERT(oldWndProc != NULL);
    if (oldWndProc != afxWndProc)
     *pOldWndProc = oldWndProc;

    pThreadState->m_pWndInit = NULL;
   }
   else
   {
    ASSERT(!bContextIsDLL);   // should never get here

    static ATOM s_atomMenu = 0;
    bool bSubclass = true;   

    if (s_atomMenu == 0)
    {
     WNDCLASSEX wc;
     memset(&wc, 0, sizeof(WNDCLASSEX));
     wc.cbSize = sizeof(WNDCLASSEX);
     s_atomMenu = (ATOM)::AfxCtxGetClassInfoEx(NULL, _T("#32768"), &wc);
    }

    // Do not subclass menus.
    if (s_atomMenu != 0)
    {
     ATOM atomWnd = (ATOM)::GetClassLongPtr(hWnd, GCW_ATOM);
     if (atomWnd == s_atomMenu)
       bSubclass = false;
    }
    else
    {
     TCHAR szClassName[256];
     if (::GetClassName(hWnd, szClassName, 256))
     {
      szClassName[255] = NULL;
      if (_tcscmp(szClassName, _T("#32768")) == 0)
       bSubclass = false;
     }
    }
    if (bSubclass)
    {
     // subclass the window with the proc which does gray backgrounds
     oldWndProc = (WNDPROC)GetWindowLongPtr(hWnd, GWLP_WNDPROC);
     if (oldWndProc != NULL && GetProp(hWnd, _afxOldWndProc) == NULL)
     {
      SetProp(hWnd, _afxOldWndProc, oldWndProc);
      if ((WNDPROC)GetProp(hWnd, _afxOldWndProc) == oldWndProc)
      {
       GlobalAddAtom(_afxOldWndProc);
       SetWindowLongPtr(hWnd, GWLP_WNDPROC, (DWORD_PTR)_AfxActivationWndProc);
       ASSERT(oldWndProc != NULL);
      }
     }
    }
   }
}

lCallNextHook:
LRESULT lResult = CallNextHookEx(pThreadState->m_hHookOldCbtFilter, code,
   wParam, lParam);

#ifndef _AFXDLL
if (bContextIsDLL)
{
   ::UnhookWindowsHookEx(pThreadState->m_hHookOldCbtFilter);
   pThreadState->m_hHookOldCbtFilter = NULL;
}
#endif
return lResult;
}

接下来就可以准备进入消息循环了

5.消息循环

大家回到前面的AfxWinMain函数中可以看到有这么一行代码：

nReturnCode = pThread->Run();//******进入消息循环*********

Run函数的源码如下：

virtual int CWinThread::Run()
{
ASSERT_VALID(this);
//是否要做空闲处理
BOOL bIdle = TRUE;
//用户记录空闲处理已经连接执行的次数
LONG lIdleCount = 0;
//acquire and dispatch messages until a WM_QUIT message is received.
//消息循环
for (;;)
{
//如果空闲状态为真，且消息队列为空，则进行空闲处理
while(bIdle && !::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE))
{
//PeekMessage()用于检查消息队列是否为空，但并不处理消息
//调用空闲处理程序，如果返回零，说明空闲处理已全部完成
    if (!OnIdle(lIdleCount++))
        bIdle = FALSE;
}
//空闲处理循环结束，进入消息泵循环
    do
    {
        //调用消息泵，提取消息并分发消息
        //如果收到WM_QUIT消息，则退出消息循环
        if (!PumpMessage())
            return ExitInstance();
        //根据刚处理的消息类型，判断是否应该在没有消息到来时立即进行空闲处理
        if (IsIdleMessage(&m_msgCur))
        {
             bIdle = TRUE;
       //在重新进行空闲处理前，清空空闲处理的执行次数
            lIdleCount = 0;
        }
    }while (::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE));
}
ASSERT(FALSE); //不可能执行的语句
}

可以看到进入消息循环后，由PumpMessage函数处理消息，是处理消息的关键，源码如下：

//省略了调试信息的输出功能
BOOL CWinThread::PumpMessage()
{
ASSERT_VALID(this);
//取出消息队列中的第一个消息，直到取得消息，该函数才返回
if (!::GetMessage(&m_msgCur, NULL, NULL, NULL))
{
//收到WM_QUIT消息
return FALSE;
}
//处理消息，但不处理WM_KICKIDLE
if (m_msgCur.message != WM_KICKIDLE && !PreTranslateMessage(&m_msgCur))
{
//转换虚键消息到字符消息
::TranslateMessage(&m_msgCur);
//分发消息
::DispatchMessage(&m_msgCur);
}
return TRUE;
}
阅读PumpMessage代码可知，消息泵并不处理WM_KICKIDLE消息，收到该消息后，直接返回。其实，WM_KICKIDLE消息被用来刺激空闲处理的执行，它作为一个空消息促使::GetMessage()返回。
虽然Run()是虚拟函数，但很少被重载。

CWinThread类是MFC用来封装线程的，包括UI线程和工作者线程。因此每个MFC程序至少使用一个CWinThread派生类。

可见Run函数和PumpMessage函数实现了Win32程序中的WinProc函数的功能。