12

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

2 回答 2

13

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

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

  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));
}

  2. 从静态窗口过程中检索实例指针并调用窗口过程成员函数：

    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将在实例指针尚不可用时调用。因此，if内部的 -statementStaticWindowProc是必需的，以便在创建期间的消息（如WM_CREATE）得到正确处理。

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

注2：如果要在底层HWND销毁的时候销毁C++类实例，WM_NCDESTROY就是这样做的地方；它是发送到任何窗口的最终消息。

于 2013-08-10T14:43:00.387 回答
1

猜你不能这样做，因为 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

}

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

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

于 2013-08-10T12:22:46.137 回答