Thread: pointer to function and typedefs

1. It is normal that typedef behaves this way because this is what it was meant to do. typedef defines a name to be associated to a certain type. In this case, the type is int(*)(int, double) (I think this is how MSVC++ puts it) and the name is ptrFunc.

2. Yes, it is common use. I know for sure that the Quake engine uses (or used) massively this feature. Quite a few functions were passed a typedef'ed pointer to function called 'use'.

Another common use is when using DLLs for plug-ins. You could very well store pointer to functions retrieved in the DLL and keep them in an object. For instance, you could have an object of a Plugin class that would have defined a WMHandlerPtr pointer to function that would be defined as bool (*) (HWND, UINT, WPARAM, LPARAM) and another FooPtr that would be defined otherwise.

Using the same example, you could say that one might want to unload a DLL and load another one (a different graphics engine for an emulator, for example). You would then already have your GraphicsDLL object created; therefore, you'd want to have an UnloadDLL() and a LoadDLL() functions. You would have to reinitialize all your pointer to functions

It isn't if you wisely use typedefs. You would just have to consider it as a new type without thinking too much about the fact it's a pointer to function.

Remember, though, the syntax may be weird, but the concept is the same as regular pointers. Functions are stored in memory addresses just like variables and a pointer to a function holds the address of the function it points to. Dereferencing it and passing it appropriate parameters will do the same as using the function directly.

Code:

typedef bool (*WMHandlerPtr) (HWND, WPARAM, LPARAM);

bool Plugin::GetWMHandlerPtr(const char* func_name) {
    myHandler = (WMHandlerPtr) GetProcAddress(myModule, func_name);
    return (myHandler == 0);
}

void Plugin::OnLButtonDown(HWND hwnd, WPARAM wprm, LPARAM lprm) {
    try {
        if(myHandler == 0)
            throw("OnLButtonDown");
        (*myHandler)(hwnd, wprm, lprm);
    } catch(const char* func) {
        if(!GetWMHandlerPtr(func))
            throw();
    }
}

I coded this on the fly and I thought maybe I'd add a little error checking but I'm not too sure about the code. It should be something like this, though.