是否可以授予顶级函数访问 C 中对象成员的权限？

Question

所以我正在为 Win32 中的 GUI 编程编写一些包装类。我从一个 Window 类开始，到目前为止它包含一个 MainLoop 方法，该方法基本上是标准 Win32 WinMain 函数的克隆。这样，我们就可以执行如下操作：

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int nCmdShow) {
  Window *win = new Window();

  // Do all your widget creation and add it to the window object...

  return win->MainLoop(hInst, hPrev, szCmdLine, nCmdShow);
}

在窗口对象的 MainLoop 方法内，它必须通过设置其 lpfnWndProc 成员来创建新的 Win32 窗口。正如任何 Win32 程序员都知道的那样，该成员是一个指向专门定义的 WndProc 函数的函数指针。问题是，如果我要创建一个 WndProc 函数，我需要访问该窗口对象的成员（以便它知道在窗口上绘制什么等）。这给我留下了两个选择（据我所知）：

1. 我可以在顶层定义WndProc，但这会切断对对象成员的访问。

2. 我可以将其定义为类方法，但它不是 lpfnWndProc 要求的确切函数类型，因此我无法设置它！

谁能帮我解开这个第 22 条军规吗？

Answer 1

您也可以将其设为静态成员函数。 :)
无论如何，解决方案取决于您是否只需要一个窗口或是否需要多个窗口。
首先是单个窗口的解决方案：

// in .h
class Window{
public:
  static LRESULT WINAPI MessageProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
  LRESULT InternalMessageProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
  // ...
};

// in .cpp
#include "Window.h"

Window* global_window = 0;

Window::Window(/*...*/){
  if(!global_window)
    global_window = this;
  else
    // error or exception... or something else
}

LRESULT WINAPI Window::MessageProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam){
  return global_window->InternalMessageProc(hWnd, msg, wParam, lParam);
}

现在，如果您想允许多个窗口，请使用 std::map （或者如果您的编译器支持 std::unordered_map）。
编辑：此解决方案存在一些微妙的问题。正如 @Ben Voigt 在他的评论中指出的那样，您会遇到先有鸡还是先有蛋的问题，因为 MessageProc 在 CreateWindow(Ex) 内部调用，但仅在 CreateWindow(Ex) 调用您就获得了窗口句柄。这是基于 Ben 的下一条评论的解决方案（谢谢！）：

// Window.h stays the same

// in .cpp
#include "Window.h"
#include <map>

std::map<HWND, Window*> window_map;
Window* currently_created_window = 0;

Window::Window(){
  currently_created_window = this;
  window_handle = CreateWindow(/*...*/);
}

LRESULT WINAPI Window::MessageProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam){
  // if the key 'hWnd' doesn't exist yet in the map
  // a new key-value pair gets created and the value gets value-initialized
  // which, in case of a pointer, is 0
  if(window_map[hWnd] == 0){
    // window doesn't exist yet in the map, add it
    window_map[hWnd] = currently_created_window;
  }
  window_map[hWnd]->InternalMessageProc(hWnd, msg, wParam, lParam);
}

不过要小心，因为上面的示例不是线程安全的。您需要互斥锁窗口的创建：

Window::Window(/*...*/){
  Lock lock_it(your_mutex);
  currently_created_window = this;
  window_handle = CreateWindow(/*...*/);
  lock_it.release();
  // rest of the initialization
}

以上应该是为了线程安全（我希望）。

Answer 2

您需要创建窗口地图，当您创建新窗口时，只需将其添加到此全局地图中即可。当然，您可以使用简单的链表来代替。

map<HWND, Window *> wndmap;

LRESULT CALLBACK WndProc(HWND hwnd, UINT Message, WPARAM wparam, LPARAM lparam)
{
    Window *pWnd = wndmap [hwnd];

    ....
}

Answer 3

WndProc 不能是实例成员函数，因为 Windows 不会传递任何隐藏的 this 参数。它可以是命名空间范围或静态成员。

一种简单的解决方案是使用 map 来查找对象，然后将参数转发到该对象的方法。

请注意，WndProc 可以维护地图本身，因为 CreateWindow 提供了一个不透明的用户参数，该参数显示在 WM_CREATE 中，这对于携带 >Window *，然后删除 WM_DESTROY 中的条目。

Answer 4

将 WndProc 定义为静态类成员 - 这将与非成员函数指针（例如 Win32 编程中使用的指针）兼容（对于我所知道的所有编译器）。

但我不得不说，这有点浪费时间 - 那里有无数的 Windows 类库，而且我不认为世界真的需要另一个。

Answer 5

听起来您需要声明该函数而不定义它。这就是原型的用途。

class Object;

void f(Object* o);

class Object {
    public:
        ...
        void some_method() {
           ... &f ...
        }

        void another_method() {
           ...
        }

        ...
};

void f(Object* o) {
    ...
    o->another_method();
    ...
}

反过来也有可能。

class Object {
    public:
        ...
        void some_method();
        void another_method();
        ...
};

void f(Object* o) {
    ...
    o->another_method();
    ...
}

void Object::some_method() {
    ... &f ...
}

void Object::another_method() {
    ...
}