What is a possible use of glfwGetWindowUserPointer?

I asked this same question on StackOverflow but didn’t get any answeres there, so I figured this place would be more suitable.

When looking through the GLFW reference I came accross the glfwGetWindowUserPointer function (and the glfwSetWindowUserPointer function). In the reference it says the following about the user-pointer:

Each window has a user pointer that can be set with glfwSetWindowUserPointer and fetched 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.

Now I wonder for what purpose one could use this?

Welcome to the forum!

A UserData field is a fairly common paradigm in C APIs that lets the user access contextual data from within callbacks without needing to make everything global. In essence, it lets you associate an arbitrary piece of data relevant to your program with a glfw window.

If you are trying to use glfw in a program that follows object-oriented design, for example, you can use this pointer to store the address of the instance that is handling a particular window, and forward the callbacks (which have to be static functions, because of the way the API works) to the appropriate member functions. e.g.

/* Constructor for the MyWindowHandler class */
MyWindowHandler (GLFWwindow * window) {
    glfwSetWindowUserPointer(window, reinterpret_cast<void *>(this));


/* Key event callback wrapper function */
static void key_callback (GLFWwindow * window, int key, int scancode, int action, int mods) {
    MyWindowHandler * handler = reinterpret_cast<MyWindowHandler *>(glfwGetWindowUserPointer(window));
    if (handler)
        handler->keyEvent(key, scancode, action, mods);
1 Like

Does using a static_cast or reinterpret_cast keyword allow you to access the object as if you were within it? If not, what does it do?

Hi @supersim135 welcome to the GLFW forum!

I’m not sure what your sentence allow you to access the object as if you were within it means. If you mean can you access private members of a class then no, neither of these casts do that.

You might find the examples in the documentation for these useful:

The purpose of the reinterpret_cast in the key_callback example is to cast from the void* pointer to a pointer of type MyWindowHandler*. This is effectively saying that the compiler should treat the memory pointed to by the pointer as being an instance (object/variable) of type MyWindowHandler.

In this case, you could also use static_cast as void* can be cast to any pointer whose object has the same alignment rules (if the original object was constructed as a MyWindowHandler then it will work).

So the following works:

void*  pVoid;
int*   pInt = static_cast<int*>(pVoid);

as does:

void*  pVoid;
int*   pInt = reinterpret_cast<int*>(pVoid);

You can also do:

float*  pFloat;
int*    pInt = reinterpret_cast<int*>(pFloat);

But you can’t do:

float*  pFloat;
int*    pInt = static_cast<int*>(pFloat); // error does not compile