如何将非静态类成员`std::bind` 绑定到 Win32 回调函数`WNDPROC`？答案

【问题标题】：How do I `std::bind` a non-static class member to a Win32 callback function `WNDPROC`?如何将非静态类成员`std::bind` 绑定到 Win32 回调函数`WNDPROC`？
【发布时间】：2013-08-12 06:29:36
【问题描述】：

我正在尝试将非静态类成员绑定到标准 WNDPROC 函数。我知道我可以通过使类成员静态来简单地做到这一点。但是，作为一名 C++11 STL 学习者，我对使用 <functional> 标头下的工具非常感兴趣。

我的代码如下。

class MainWindow
{
    public:
        void Create()
        {
            WNDCLASSEXW WindowClass;
            WindowClass.cbSize          = sizeof(WNDCLASSEX);
            WindowClass.style           = m_ClassStyles;
            WindowClass.lpfnWndProc     = std::function<LRESULT(HWND, UINT, WPARAM, LPARAM)>
                                            (   std::bind(&MainWindow::WindowProc, 
                                                *this,
                                                std::placeholders::_1,
                                                std::placeholders::_2,
                                                std::placeholders::_3,
                                                std::placeholders::_4));
            WindowClass.cbClsExtra      = 0;
            WindowClass.cbWndExtra      = 0;
            WindowClass.hInstance       = m_hInstance;
            WindowClass.hIcon           = LoadIconW(m_hInstance, MAKEINTRESOURCEW(IDI_WINDOW));
            WindowClass.hCursor         = LoadCursor(NULL, IDC_ARROW);
            WindowClass.hbrBackground   = (HBRUSH) COLOR_WINDOW;
            WindowClass.lpszMenuName    = MAKEINTRESOURCEW(IDR_MENU);
            WindowClass.lpszClassName   = m_ClassName.c_str();
            WindowClass.hIconSm         = LoadIconW(m_hInstance, MAKEINTRESOURCEW(IDI_WINDOW_SMALL));
            RegisterClassExW(&WindowClass);
            m_hWnd = CreateWindowEx(/*_In_      DWORD*/     ExtendedStyles,
                                    /*_In_opt_  LPCTSTR*/   m_ClassName.c_str(),
                                    /*_In_opt_  LPCTSTR*/   m_WindowTitle.c_str(),
                                    /*_In_      DWORD*/     m_Styles,
                                    /*_In_      int*/       m_x,
                                    /*_In_      int*/       m_y,
                                    /*_In_      int*/       m_Width,
                                    /*_In_      int*/       m_Height,
                                    /*_In_opt_  HWND*/      HWND_DESKTOP,
                                    /*_In_opt_  HMENU*/     NULL,
                                    /*_In_opt_  HINSTANCE*/ WindowClass.hInstance,
                                    /*_In_opt_  LPVOID*/    NULL);

        }

    private:
        LRESULT CALLBACK WindowProc(_In_ HWND hwnd,
                                    _In_ UINT uMsg,
                                    _In_ WPARAM wParam,
                                    _In_ LPARAM lParam)
        {
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
        }
};

当我按原样运行它时，它会给出错误消息：

Error: no suitable conversion function from "std::function<LRESULT(HWND, UINT, WPARAM, LPARAM)>" to "WNDPROC".

【问题讨论】：

标签： c++ winapi wndproc std-function stdbind

【解决方案1】：

虽然 JohnB 已经详细解释了为什么这是不可能的，但这里有一个针对您要解决的问题的常见解决方案：授予对静态类成员的类实例访问权限。

解决方案的指导原则是实例指针必须以静态类成员可访问的方式存储。在处理窗口时，额外的窗口内存是存储这些信息的好地方。额外窗口内存的请求空间通过WNDCLASSEXW::cbWndExtra指定，而数据访问通过SetWindowLongPtr和GetWindowLongPtr提供。

构造后在窗口额外数据区存储一个实例指针：

void Create()
{
    WNDCLASSEXW WindowClass;
    // ...
    // Assign the static WindowProc
    WindowClass.lpfnWndProc = &MainWindow::StaticWindowProc;
    // Reserve space to store the instance pointer
    WindowClass.cbWndExtra  = sizeof(MainWindow*);
    // ...
    RegisterClassExW(&WindowClass);
    m_hWnd = CreateWindowEx( /* ... */ );

    // Store instance pointer
    SetWindowLongPtrW(m_hWnd, 0, reinterpret_cast<LONG_PTR>(this));
}

从静态窗口过程中获取实例指针并调用窗口过程成员函数：

static LRESULT CALLBACK StaticWindowProc( _In_ HWND hwnd,
                                          _In_ UINT uMsg,
                                          _In_ WPARAM wParam,
                                          _In_ LPARAM lParam )
{
    // Retrieve instance pointer
    MainWindow* pWnd = reinterpret_cast<MainWindow*>(GetWindowLongPtrW(hwnd, 0));
    if ( pWnd != NULL )  // See Note 1 below
        // Call member function if instance is available
        return pWnd->WindowProc(hwnd, uMsg, wParam, lParam);
    else
        // Otherwise perform default message handling
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

类成员WindowProc的签名与您提供的代码中的签名相同。

这是实现所需行为的一种方式。 Remy Lebeau 提出了一个变体，它的好处是让所有消息都通过类成员WindowProc 路由：

在窗口额外数据中分配空间（同上）：

void Create()
{
    WNDCLASSEXW WindowClass;
    // ...
    // Assign the static WindowProc
    WindowClass.lpfnWndProc = &MainWindow::StaticWindowProc;
    // Reserve space to store the instance pointer
    WindowClass.cbWndExtra  = sizeof(MainWindow*);
    // ...

将实例指针传递给CreateWindowExW：

    m_hWnd = CreateWindowEx( /* ... */,
                             static_cast<LPVOID>(this) );
    // SetWindowLongPtrW is called from the message handler
}

当第一条消息（WM_NCCREATE）发送到窗口时，提取实例指针并存储在窗口额外数据区中：

static LRESULT CALLBACK StaticWindowProc( _In_ HWND hwnd,
                                          _In_ UINT uMsg,
                                          _In_ WPARAM wParam,
                                          _In_ LPARAM lParam )
{
    // Store instance pointer while handling the first message
    if ( uMsg == WM_NCCREATE )
    {
        CREATESTRUCT* pCS = reinterpret_cast<CREATESTRUCT*>(lParam);
        LPVOID pThis = pCS->lpCreateParams;
        SetWindowLongPtrW(hwnd, 0, reinterpret_cast<LONG_PTR>(pThis));
    }

    // At this point the instance pointer will always be available
    MainWindow* pWnd = reinterpret_cast<MainWindow*>(GetWindowLongPtrW(hwnd, 0));
    // see Note 1a below
    return pWnd->WindowProc(hwnd, uMsg, wParam, lParam);
}

注意 1：实例指针在窗口创建后存储到窗口额外数据区域，而 lpfnWndProc 在创建之前设置。这意味着StaticWindowProc 将在实例指针尚不可用时被调用。因此，StaticWindowProc 中的 if-statement 是必需的，以便创建期间的消息（如 WM_CREATE）得到正确处理。

注 1a：注 1 中所述的限制不适用于替代实现。实例指针将从第一条消息开始可用，因此将为所有消息调用类成员 WindowProc。

注意2：如果你想在底层HWND被销毁时销毁C++类实例，WM_NCDESTROY是这样做的地方；它是发送到任何窗口的最后一条消息。

【讨论】：

您可以将实例指针传递给 CreateWindowEx() 本身，然后在 WM_NCCREATE 消息处理程序中调用 SetWindowLongPtr()，而不是在 CreateWindowEx() 之后调用 SetWindowLongPtr()。
@Remy 感谢您指出另一种实现方式。我更新了答案以包含您的建议。
如果您将GWLP_USERDATA 与SetWindowLongPtr() 一起使用，则根本不需要设置窗口的cbWndExtra。
@Remy 确实如此，但是，GWLP_USERDATA 在今天基本上是无用的，因为每个人和他们的狗 (ab) 都使用它来存储他们宝贵的数据（例如，在子类化时）。每当您控制窗口类注册时，使用该“私有”区域会更可靠。从技术上讲，没有区别 - 任何人都可以访问这两个区域。然而，额外的窗口内存不像GWLP_USERDATA那样被视为公共领域。
你错了。有可能的。我想你没有听说过 thunking。

【解决方案2】：

猜你不能这样做，因为 WNDPROC 代表函数指针。每个函数指针都可以转换为 std::function，但并不是每个 std::function 都代表一个函数指针。

您的计划不可能的证明：从技术上讲，WNDPROC 仅表示要调用的内存中函数的地址。因此，WNDPROC 类型的变量不包含“空格”来存储有关绑定参数的信息。

和下面的例子是一样的问题：

typedef void (* callbackFn) ();

struct CallingObject {
    callbackFn _callback;

    CallingObject (callbackFn theCallback) : _callback (theCallback) {
    }

    void Do () {
       _callback ();
    }
};

void f () { std::cout << "f called"; }
void g () { std::cout << "g called"; }
void h (int i) { std::cout << "h called with parameter " << i; }

int main () {
    CallingObject objF (f); objF.Do (); // ok
    CallingObject objG (g); objG.Do (); // ok

}

然而，为了从 CallingObject 调用 h 并在运行时确定一些参数值，您必须将参数值存储在静态变量中，然后编写一个调用 h 的包装函数，并将该值作为参数。

这就是回调函数通常采用void * 类型参数的原因，您可以在其中传递计算所需的任意数据。

【讨论】：