MFC、ATL窗口消息封装机制对比分析

最新推荐文章于 2022-07-18 09:32:07 发布

followme163

最新推荐文章于 2022-07-18 09:32:07 发布

阅读量2.3k

点赞数

http://www.brucesky.com/articles/242

新产品在不紧不慢的进行中，这应该是有史以来开发比较“自由”的一个项目。在折腾完一个功能服务器的demo之后，开始折腾起PC客户端。Leader说客户端界面需用ATL来实现。这时候可以满足一下客户端界面开发的兴趣，于是开始学习ATL界面开发，有人说做界面是个累人加无趣的体力活，但对于做界面的新手来说自得其乐，君子懂得善假于物的道理，短期不允许重新造轮子，于是使用了kui做铺垫。现在要讨论的与kui无关，只讨论MFC和ATL对窗口消息封装的实现手法。一切还是从调试源码过程中寻找答案，进入正题。

我们知道，一个标准Windows App的主要逻辑有：1.注册一个窗口类/窗口过程；2.创建该类窗口；3.显示、激活窗口；4.消息循环；5.处理该窗口感兴趣的消息。

我们又知道，Win32 API是面向过程的（虽然可以说Windows是一个OO系统），而我们希望可以利用Win32 API进行快乐的OOP（不需要重复上面的逻辑）编程，于是，我们需要包装API，封装Windows窗口。从上面的逻辑可以看出，要封装窗口主要需解决怎样封装窗口消息处理机制。由于交给Windows调用的标准窗口过程是全局/静态的，此时，将面临两个问题：

1.怎么知道将窗口过程中的消息转发给对应封装好的窗口类实例？（也就是HWND到对应窗口类实例的转换）

2.假设第1个问题解决了，怎样将消息传递给相应窗口类的实例？

重点是解决第1个问题，下面来看MFC和ATL分别是怎么来解决这两个问题。

一、MFC窗口消息封装机制

我们通过一个手工产生（not by wizzard）的最简单的MFC程序（基于CWinApp和CWnd的两个类，以省掉不必要的代码和麻烦）开始调试分析。

 
BOOL CMFCApp::InitInstance()
 
{
 
    CMFCWin* pMainWnd = new CMFCWin;
 
    if (NULL == pMainWnd)
 
        return FALSE;
 
 
 
    CString strWndClass;
 
    strWndClass = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW,
 
        ::LoadCursor(NULL, IDC_ARROW), HBRUSH(COLOR_WINDOW+1), NULL);
 
 
 
    HMENU hMenu = ::LoadMenu(NULL, MAKEINTRESOURCE(IDR_MAINFRAME));
 
    // Bruce：开始创建主窗口
 
    if (!pMainWnd->CreateEx(WS_EX_APPWINDOW, strWndClass,
 
        _T("MFCBased without Wizzard"), WS_OVERLAPPEDWINDOW,
 
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 
        NULL, hMenu, NULL))
 
    {
 
        AfxMessageBox(_T("CreateEx Failed!"));
 
        return FALSE;
 
    }
 
 
 
    m_pMainWnd = pMainWnd;
 
    pMainWnd->ShowWindow(m_nCmdShow);
 
    pMainWnd->UpdateWindow();
 
 
 
    return TRUE;
 
}

进入pMainWnd->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)
 
{
 
    // . . .
 
    // Bruce：Hook? 好戏来了。
 
    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);
 
 
 
}

AfxHookWindowCreate，看上去是装了个Hook，进去看。

 
void AFXAPI AfxHookWindowCreate(CWnd* pWnd)
 
{
 
    // Bruce：这里取的什么数据？
 
    _AFX_THREAD_STATE* pThreadState = _afxThreadState.GetData();
 
    if (pThreadState->m_pWndInit == pWnd)
 
        return;
 
 
 
    if (pThreadState->m_hHookOldCbtFilter == NULL)
 
    {
 
        // Bruce：果然，这里装了个WH_CBT钩子
 
        pThreadState->m_hHookOldCbtFilter = ::SetWindowsHookEx(WH_CBT,
 
            _AfxCbtFilterHook, NULL, ::GetCurrentThreadId());
 
        if (pThreadState->m_hHookOldCbtFilter == NULL)
 
            AfxThrowMemoryException();
 
    }
 
    // . . .
 
    pThreadState->m_pWndInit = pWnd;
 
}

先来说_afxThreadState.GetData()，_afxThreadState是一个全局CThreadLocal模板对象，是对TLS的封装，记录了线程相关的私有数据，_afxThreadState后面还会看到。接下来我们看到安装了一个WH_CBT钩子，_AfxCbtFilterHook是hook procedure，用来监视窗口的激活，创建，销毁等消息，也就是在窗口被激活，创建，销毁的时候系统会先调用这个函数。下面来看_AfxCbtFilterHook做了些什么。

 
LRESULT CALLBACK
 
_AfxCbtFilterHook(int code, WPARAM wParam, LPARAM lParam)
 
{
 
    _AFX_THREAD_STATE* pThreadState = _afxThreadState.GetData();
 
    if (code != HCBT_CREATEWND) // Bruce：只关心窗口创建消息，其他跳过
 
    {
 
        // wait for HCBT_CREATEWND just pass others on...
 
        return CallNextHookEx(pThreadState->m_hHookOldCbtFilter, code,
 
            wParam, lParam);
 
    }
 
    // . . .
 
    LPCREATESTRUCT lpcs = ((LPCBT_CREATEWND)lParam)->lpcs;
 
    // . . .
 
    HWND hWnd = (HWND)wParam;
 
    WNDPROC oldWndProc;
 
    if (pWndInit != NULL)
 
    {
 
        AFX_MANAGE_STATE(pWndInit->m_pModuleState);
 
 
 
        // Bruce：检查该窗口映射是否存在？后面说明这个函数
 
        ASSERT(CWnd::FromHandlePermanent(hWnd) == NULL);
 
 
 
        // Bruce：添加窗口映射（HWND  CWnd）
 
        pWndInit->Attach(hWnd);
 
        // allow other subclassing to occur first
 
        pWndInit->PreSubclassWindow();
 
 
 
        WNDPROC *pOldWndProc = pWndInit->GetSuperWndProcAddr();
 
        ASSERT(pOldWndProc != NULL);
 
 
 
        // Bruce：subclass，重新设置窗口过程
 
        WNDPROC afxWndProc = AfxGetAfxWndProc();
 
        oldWndProc = (WNDPROC)SetWindowLongPtr(hWnd, GWLP_WNDPROC,
 
                (DWORD_PTR)afxWndProc);
 
        ASSERT(oldWndProc != NULL);
 
        if (oldWndProc != afxWndProc)
 
            *pOldWndProc = oldWndProc;
 
 
 
        pThreadState->m_pWndInit = NULL;
 
    }
 
    // . . .
 
}

这里可以看到，钩子函数仅监视窗口的创建，通过FromHandlePermanent/Attach完成了HWND到CWnd的映射，并重新设置了窗口过程。这个窗口过程视链接MFC的方式不同要么是AfxWndProcBase或AfxWndProc，即Windows想要的标准窗口过程。

 
CWnd* PASCAL CWnd::FromHandlePermanent(HWND hWnd)
 
{
 
    CHandleMap* pMap = afxMapHWND();
 
    CWnd* pWnd = NULL;
 
    if (pMap != NULL)
 
    {
 
        // only look in the permanent map - does no allocations
 
        pWnd = (CWnd*)pMap->LookupPermanent(hWnd);
 
        ASSERT(pWnd == NULL || pWnd->m_hWnd == hWnd);
 
    }
 
    return pWnd;
 
}
 
 
 
BOOL CWnd::Attach(HWND hWndNew)
 
{
 
    ASSERT(m_hWnd == NULL);     // only attach once, detach on destroy
 
    ASSERT(FromHandlePermanent(hWndNew) == NULL);
 
        // must not already be in permanent map
 
 
 
    if (hWndNew == NULL)
 
        return FALSE;
 
 
 
    CHandleMap* pMap = afxMapHWND(TRUE); // create map if not exist
 
    ASSERT(pMap != NULL);
 
 
 
    pMap->SetPermanent(m_hWnd = hWndNew, this);
 
    // . . .
 
}

通过查看FromHandlePermanent/Attach的实现，可以发现HWND到CWnd的映射建立在Map的机制上，另外，查看afxMapHWND()的实现，可以发现，这个映射关系也保存在线程的TLS中，因此有了MFC的一个先天限制，不能把一个MFC对象从某线程手上交给另一线程，也不能够在线程之间传递MFC对象指针（了解更多可以参考《Win32多线程程序设计》MFC多线程一章）。下面再看看窗口过程。

 
WNDPROC AFXAPI AfxGetAfxWndProc()
 
{
 
#ifdef _AFXDLL // Bruce：Use MFC in a Shared DLL
 
    return AfxGetModuleState()->m_pfnAfxWndProc; // Bruce：也就是AfxWndProcBase
 
#else // Bruce：Use MFC in a Static Library
 
    return &AfxWndProc;
 
#endif
 
}
 
 
 
LRESULT CALLBACK
 
AfxWndProcBase(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
 
{
 
    AFX_MANAGE_STATE(_afxBaseModuleState.GetData());
 
    return AfxWndProc(hWnd, nMsg, wParam, lParam);
 
}
 
 
 
LRESULT CALLBACK
 
AfxWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
 
{
 
    // special message which identifies the window as using AfxWndProc
 
    if (nMsg == WM_QUERYAFXWNDPROC)
 
        return 1;
 
 
 
    // Bruce：查找Map，找到HWND对应的CWnd实例
 
    CWnd* pWnd = CWnd::FromHandlePermanent(hWnd);
 
    ASSERT(pWnd != NULL);
 
    ASSERT(pWnd==NULL || pWnd->m_hWnd == hWnd);
 
    if (pWnd == NULL || pWnd->m_hWnd != hWnd)
 
        return ::DefWindowProc(hWnd, nMsg, wParam, lParam);
 
    return AfxCallWndProc(pWnd, hWnd, nMsg, wParam, lParam); // Bruce：有了CWnd，可以调用窗口实例对应的窗口过程
 
}
 
 
 
LRESULT AFXAPI AfxCallWndProc(CWnd* pWnd, HWND hWnd, UINT nMsg,
 
    WPARAM wParam = 0, LPARAM lParam = 0)
 
{
 
    _AFX_THREAD_STATE* pThreadState = _afxThreadState.GetData();
 
    MSG oldState = pThreadState->m_lastSentMsg; // save for nesting
 
    pThreadState->m_lastSentMsg.hwnd = hWnd;
 
    pThreadState->m_lastSentMsg.message = nMsg;
 
    pThreadState->m_lastSentMsg.wParam = wParam;
 
    pThreadState->m_lastSentMsg.lParam = lParam;
 
 
 
    #ifdef _DEBUG
 
        _AfxTraceMsg(_T("WndProc"), &pThreadState->m_lastSentMsg);
 
    #endif
 
 
 
    // Catch exceptions thrown outside the scope of a callback
 
    // in debug builds and warn the user.
 
    LRESULT lResult;
 
    TRY
 
    {
 
        // . . .
 
        // Bruce：“终于找到属于我的窗口过程了！”，WindowProc是一个virtual function，注意与AfxWndProc的区别
 
        lResult = pWnd->WindowProc(nMsg, wParam, lParam);
 
    }
 
// . . .
 
}

到此，我们已经完整的看到了MFC封装窗口消息机制的过程，简单总结一下：
通过Hook技术安装一个WH_CBT钩子，在窗口创建时（必须在这个时候，这样才不会有漏网的窗口消息）建立HWND到窗口类实例（如CWnd实例）的映射关系，并保存在创建该窗口的线程的TLS中，然后在需要的时候从TLS中取出数据查找关系Map。MFC就是通过这样的方式解决了开始提出的第1个问题，而第2个问题则通过虚函数来实现。

二、ATL窗口消息封装机制

这里也手工写了一个简单的ATL窗口程序，基于CWindowImpl窗口类。开始调试。

 
int APIENTRY _tWinMain(
 
    HINSTANCE hInst,
 
    HINSTANCE /*hInstPrev*/,
 
    LPTSTR pszCmdLine,
 
    int nCmdShow)
 
{
 
    _Module.Init(0, hInst);
 
 
 
    HMENU hMenu = ::LoadMenu(_Module.GetResourceInstance(),
 
        MAKEINTRESOURCE(IDR_MENU));
 
 
 
    CATLWin mainWnd;
 
    // Bruce：开始创建主窗口
 
    if (!mainWnd.Create(NULL, CWindow::rcDefault,
 
        _T("ATLBased without Wizzard"), 0, 0, (UINT)hMenu))
 
    {
 
        ::MessageBox(NULL, _T("Create Failed"), _T("ATLBased Error"), MB_OK);
 
        return -1;
 
    }
 
 
 
    mainWnd.CenterWindow();
 
    mainWnd.ShowWindow(nCmdShow);
 
    mainWnd.UpdateWindow();
 
 
 
    MSG msg;
 
    while (::GetMessage(&msg, NULL, 0, 0))
 
    {
 
        ::TranslateMessage(&msg);
 
        ::DispatchMessage(&msg);
 
    }
 
 
 
    _Module.Term();
 
    return msg.wParam;
 
}

依旧是从创建窗口开始，看看CWindowImpl::Create做了什么。

 
HWND Create(HWND hWndParent, _U_RECT rect = NULL,
 
    LPCTSTR szWindowName = NULL,
 
    DWORD dwStyle = 0, DWORD dwExStyle = 0,
 
    _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
 
{
 
    if (T::GetWndClassInfo().m_lpszOrigName == NULL)
 
        T::GetWndClassInfo().m_lpszOrigName = GetWndClassName();
 
    ATOM atom = T::GetWndClassInfo().Register(&m_pfnSuperWindowProc);
 
 
 
    dwStyle = T::GetWndStyle(dwStyle);
 
    dwExStyle = T::GetWndExStyle(dwExStyle);
 
 
 
    // . . .
 
 
 
    return CWindowImplBaseT< TBase, TWinTraits >::Create(hWndParent, rect,
 
        szWindowName, dwStyle, dwExStyle, MenuOrID, atom, lpCreateParam);
 
}

函数一开始通过GetWndClassInfo获取默认的WndClass并注册，GetWndClassInfo通过宏DECLARE_WND_CLASS实现，展开可以发现默认的窗口过程是StartWindowProc，继续看CWindowImplBaseT< TBase, TWinTraits >::Create。

 
template
 
HWND CWindowImplBaseT< TBase, TWinTraits >::Create(
 
    HWND hWndParent, _U_RECT rect, LPCTSTR szWindowName,
 
    DWORD dwStyle, DWORD dwExStyle, _U_MENUorID MenuOrID,
 
    ATOM atom, LPVOID lpCreateParam)
 
{
 
    // . . .
 
    // Allocate the thunk structure here, where we can fail gracefully.
 
    result = m_thunk.Init(NULL,NULL);
 
    // . . .
 
    _AtlWinModule.AddCreateWndData(&m_thunk.cd, this);
 
    // . . .
 
 
 
    HWND hWnd = ::CreateWindowEx(dwExStyle, MAKEINTATOM(atom),
 
        szWindowName,dwStyle, rect.m_lpRect->left, rect.m_lpRect->top,
 
        rect.m_lpRect->right - rect.m_lpRect->left,
 
        rect.m_lpRect->bottom - rect.m_lpRect->top,
 
        hWndParent, MenuOrID.m_hMenu,
 
        _AtlBaseModule.GetModuleInstance(), lpCreateParam);
 
 
 
    ATLASSUME(m_hWnd == hWnd);
 
 
 
    return hWnd;
 
}

我们看到这里开始使用了thunk成员变量m_thunk，thunk一般可以理解为转换，在这里是一组ASM指令。每个CWindowImpl实例有自己的m_thunk，这里暂不管thunk的技术实现，只需留意窗口this指针和ThreadId被安全的放进一个_AtlCreateWndData全局链表结构中。下面就来看窗口过程StartWindowProc。

 
template
 
LRESULT CALLBACK CWindowImplBaseT< TBase, TWinTraits >::
 
StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 
{
 
    // Bruce：通过当前的ThreadId遍历_AtlCreateWndData链表，取得先前保存的窗口this指针
 
    CWindowImplBaseT< TBase, TWinTraits >* pThis = (CWindowImplBaseT< TBase, TWinTraits >*)_AtlWinModule.ExtractCreateWndData();
 
    // . . .
 
    // Bruce：这里保存HWND以作后用，thunking过程中将被覆盖掉
 
    pThis->m_hWnd = hWnd;
 
 
 
    // Bruce：将静态窗口过程（如果GetWindowProc没被改写，那么就是CWindowImplBaseT::WindowProc）和this指针初始化到thunk中， m_thunk.Init之后，hWnd被替换成this指针
 
    pThis->m_thunk.Init(pThis->GetWindowProc(), pThis);
 
    // Bruce：这里返回的其实是一个_stdcallthunk结构体的首地址，后面会提及
 
    WNDPROC pProc = pThis->m_thunk.GetWNDPROC();
 
    // . . .
 
    // Bruce：进入静态窗口过程
 
    return pProc(hWnd, uMsg, wParam, lParam);
 
}

继续看CWindowImplBaseT::WindowProc。

 
template
 
LRESULT CALLBACK CWindowImplBaseT< TBase, TWinTraits >::WindowProc(
 
    HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 
{
 
    // Bruce：hWnd变回this（thunk的功劳）
 
    CWindowImplBaseT< TBase, TWinTraits >* pThis = (CWindowImplBaseT< TBase, TWinTraits >*)hWnd;
 
    // . . .
 
 
 
    // Bruce：转换过程到这里结束，找到this的virtual成员函数处理窗口消息
 
    BOOL bRet = pThis->ProcessWindowMessage(pThis->m_hWnd, uMsg, wParam, lParam, lRes, 0);
 
    // . . .
 
}

到这里，大致看完了ATL为了解决第1个问题进行的转换过程，总结起来就是：通过thunk的作用，对hWnd做缓存后将Windows提供的hWnd替换成this指针，接着thunk把整个调用栈传递给真正的窗口过程（如果GetWindowProc没被改写，也就是CWindowImplBaseT::WindowProc）。
最后再来看有趣的thunk是怎么实现的。

 
class CWndProcThunk
 
{
 
public:
 
    _AtlCreateWndData cd;
 
    CStdCallThunk thunk;
 
 
 
    BOOL Init(WNDPROC proc, void* pThis)
 
    {
 
        return thunk.Init((DWORD_PTR)proc, pThis);
 
    }
 
    WNDPROC GetWNDPROC()
 
    {
 
        return (WNDPROC)thunk.GetCodeAddress();
 
    }
 
};

不管内存字节对齐方式，这里假设CStdCallThunk为_stdcallthunk，在_M_IX86平台下。

 
#if defined(_M_IX86)
 
PVOID __stdcall __AllocStdCallThunk(VOID);
 
VOID  __stdcall __FreeStdCallThunk(PVOID);
 
 
 
#pragma pack(push,1)    // Bruce：1字节内存对齐方式
 
struct _stdcallthunk
 
{
 
    DWORD   m_mov;          // mov dword ptr [esp+0x4], pThis (esp+0x4 is hWnd)
 
    DWORD   m_this;         //
 
    BYTE    m_jmp;          // jmp WndProc
 
    DWORD   m_relproc;      // relative jmp
 
    BOOL Init(DWORD_PTR proc, void* pThis)
 
    {
 
        m_mov = 0x042444C7;  //C7 44 24 0C
 
        m_this = PtrToUlong(pThis);
 
        m_jmp = 0xe9;
 
        m_relproc = DWORD((INT_PTR)proc - ((INT_PTR)this+sizeof(_stdcallthunk)));
 
        // write block from data cache and
 
        //  flush from instruction cache
 
        FlushInstructionCache(GetCurrentProcess(), this,sizeof(_stdcallthunk));
 
        return TRUE;
 
    }
 
    //some thunks will dynamically allocate the memory for the code
 
    void* GetCodeAddress()
 
    {
 
        return this;
 
    }
 
    void* operator new(size_t)
 
    {
 
        return __AllocStdCallThunk();
 
    }
 
    void operator delete(void* pThunk)
 
    {
 
        __FreeStdCallThunk(pThunk);
 
    }
 
};
 
#pragma pack(pop)

三、其他实现

除了MFC、ATL中使用的手法，还有另外一种简单的封装方式。且看代码，主要是窗口过程。

 
LRESULT CALLBACK XWindow::WndProc(HWND hWnd, UINT uMsg,
 
    WPARAM wParam, LPARAM lParam)
 
{
 
    XWindow* pThis = NULL;
 
    if (WM_NCCREATE == uMsg)
 
    {
 
        assert(!::IsBadReadPtr((void*)lParam, sizeof(CREATESTRUCT)));
 
        LPCREATESTRUCT lpcs = reinterpret_cast(lParam);
 
        pThis = static_cast(lpcs->lpCreateParams);
 
        pThis->m_hWnd = hWnd;
 
 
 
        assert(!::IsBadReadPtr(pThis, sizeof(XWindow)));
 
        ::SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast(pThis));
 
    }
 
    else
 
        pThis = reinterpret_cast(::GetWindowLongPtr(hWnd, GWLP_USERDATA));
 
 
 
    if (pThis)
 
        return pThis->MsgProc(hWnd, uMsg, wParam, lParam);
 
    else
 
        return DefWindowProc(hWnd, uMsg, wParam, lParam);
 
}

这种方式通过在收到 WM_NCCREATE消息时，将this指针保存在lParam参数中，lParam事实上是一个LPCREATESTRUCT结构指针。成功保存后，WM_NCCREATE之后的消息就可以取出this指针，调用对应的消息处理函数。一些UI库使用的是这种实现方式。

到此，分析结束，由于MFC、ATL的设计目标不同（MFC在于简单易用，ATL则是短小精悍），MFC、ATL采用了不同的实现手法，且各有优劣。MFC采用全局映射表的方式，由于需要查找，损耗一定的时间，并随着窗口数的增多而增长。ATL在效率上占优势，但增加了一些复杂性。

本文调试源码：brucesky_window_bind_comp

followme163

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
MFC、ATL窗口消息封装机制对比分析

http://www.brucesky.com/articles/242新产品在不紧不慢的进行中，这应该是有史以来开发比较“自由”的一个项目。在折腾完一个功能服务器的demo之后，开始折腾起PC客户端。Leader说客户端界面需用ATL来实现。这时候可以满足一下客户端界面开发的兴趣，于是开始学习ATL界面开发，有人说做界面是个累人加无趣的体力活，但对于做界面的新手来说自得其乐，君子懂得
复制链接

扫一扫