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

Question

我正在尝试将非静态类成员绑定到标准的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".

- hkBattousai

Answer 1

尽管JohnB已经解释了为什么这是不可能的细节，但以下是解决您要解决的问题的常见方法：授予类实例访问静态类成员。

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

1. 在构造之后，将实例指针存储在窗口额外数据区中：

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路由：

1. 在窗口额外数据中分配空间（与上面相同）：

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

2. 将实例指针传递给 CreateWindowExW：

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

3. 在向窗口发送第一个消息(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语句是必需的，以便能正确地处理创建期间（例如WM_CREATE）的消息。

注1a：注意1中所述的限制不适用于替代实现。从第一条消息开始，实例指针将可用，并且类成员函数WindowProc将相应地处理所有消息。

注2：如果要在底层的HWND被销毁时销毁C++类实例，则应在WM_NCDESTROY中执行；这是发送给任何窗口的最后一条消息。

- IInspectable

---

不必在CreateWindowEx()之后调用SetWindowLongPtr()函数，您可以将实例指针直接传递给CreateWindowEx()，然后在WM_NCCREATE消息处理程序中调用SetWindowLongPtr()函数。 - Remy Lebeau

@Remy 感谢您指出另一种实现方式。我已更新答案以包含您的建议。 - IInspectable

@user2345215 请仔细阅读问题。理解我的回答上下文。不要把这变成一场自我炫耀的竞赛。 - IInspectable

@IInspectable：你提到另一个答案，其中证明存在缺陷，可以通过在运行时创建可执行代码来创建空间。所以我的观点仍然成立。顺便说一下，我特意因为你而提出了一个关于const的问题。自己看看吧。 - user2345215

@user2345215 为什么不评论那个答案，而是下投票那个答案而不是我的？你能看到问题所在吗？此外，在运行时创建可执行代码将会使一些防病毒应用程序感到不安。 - IInspectable

Answer 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*类型参数的原因，在其中可以传递所需的任意数据以进行计算。

- JohnB