如何使用函数对象作为回调来调用对象中的成员函数（处理程序）？

Question

I wanted to create a window_callback function object that I could use in glfwSet[...]Callback() functions. It is supposed to find a window in the inline static std::unordered_map<GLFWwindow*, window&> windows_by_handles by its GLFWwindow* handle and than call its appropriate handler. This is my current code:

template <typename... Args>
class window_callback
{
    typedef void(window::*member_func_t)(Args...);
    member_func_t func;
public:
    window_callback(member_func_t func_) :
        func(func_)
    {
    }

    void operator() (GLFWwindow* HWND, Args... args)
    {
        try
        {
            window& wnd = windows_by_handles.at(HWND);
            (wnd.*func)(args...); //error E0165
        }
        catch (const std::out_of_range&)
        {
            std::cerr << "Detected callback for unknown window\n";
        }
    }

    operator decltype(&(operator()))() { return &operator(); }
};

The window_callback objects are created in the following manner (inside the window class):

inline static window_callback<int, int> resize_callback{ &on_resize };
inline static window_callback<double, double> mouse_movement_callback{ &on_mouse_moved };
inline static window_callback<double, double> scroll_callback{ &on_scrolled };

Then, they are bound with glfwSet[...]Callback() functions like this (inside the window class constructor):

glfwSetFramebufferSizeCallback(handle, resize_callback);
glfwSetCursorPosCallback(handle, mouse_movement_callback);
glfwSetScrollCallback(handle, scroll_callback);

The given code doesn't compile. It gives the following errors when compiling in Visual Studio 2019 (using C++17). The first 2 errors happen on the user-defined conversion operator declaration:

• C2833 'operator type' is not a recognized operator or type

• C2059 syntax error: 'newline'

• C2664 GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow *,GLFWframebuffersizefun) : cannot convert argument 2 from window::window_callback<int,int> to GLFWframebuffersizefun

• C2664 GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow *,GLFWcursorposfun) : cannot convert argument 2 from window::window_callback<double,double> to GLFWcursorposfun
• C2664 GLFWscrollfun glfwSetScrollCallback(GLFWwindow *,GLFWscrollfun) : cannot convert argument 2 from window::window_callback<double,double> to GLFWscrollfun

The problematic part is the conversion from the window_callback type to the appropriate function pointer types. What should be changed to make this code work or what is an alternate solution that will work in the same manner?

Answer 1

How to use function object as callback to invoke member functions (handlers) in an object?

that I could use in glfwSet[...]Callback() functions.

Glfw does not accept member function pointers as callback functions, nor does it accept function objects.

You can only register function pointers. Function pointers cannot point to non-static member functions. The function call operator overload of a function object is also a member function.

You need to write a non-member function (or you can use a static member function if you prefer) that wraps the call to the member function (or a function object if you prefer).

Example:

struct C {
    void window_size(GLFWwindow*, int, int);
};

auto window_size_callback = [](GLFWwindow* window, int w, int h) {
    C c;
    c.window_size(window, w, h);
}; // a non-capturing lambda can be converted to a function pointer
   // you can use a named function if you prefer

glfwSetWindowSizeCallback(window, window_size_callback);

But, presumably you need access to some particular instance of the class (or function object), rather than a default constructed one. After all, why use a non-static member function if that wasn't the case. To achieve that, you need some way of passing a reference to that object into the callback.

The way documented by GLFW is:

Each window has a user pointer that can be set with glfwSetWindowUserPointer and queried with glfwGetWindowUserPointer . This can be used for any purpose you need and will not be modified by GLFW throughout the life-time of the window.

If all of your callbacks are to be called on a single object, using this is simple:

C c;
glfwSetWindowUserPointer(window, &c);

auto window_size_callback = [](GLFWwindow* window, int w, int h) {
    C* cptr = static_cast<C*>(glfwSetWindowUserPointer(window));
    assert(c);
    cptr->window_size(window, w, h);
};

Unfortunately, GLFW API doesn't appear to support callback specific user data. If you need different objects for different callbacks, you could possibly use your own map from callback to object, but that's not quite as simple as the example above.

Furthermore, be very careful to keep the object alive at least as long as the window is alive so that callbacks don't get called on a dangling pointer.