Question

this class is much larger, but i’ll just post the offending code.

template<class T>
class BaseWindow : public IWindow
{
   typedef void(T::*HandlerPtr)(WPARAM, LPARAM)

public:
   LRESULT CALLBACK BaseWindow<T>::WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);

   // various stuff

private:
   void AddHandler(long id, HandlerPtr func);

private:
   std::map<long, void(T::*)(WPARAM, LPARAM)> m_MessageHandlers;
}

template<class T>
void BaseWindow<T>::AddHandler(long id, HandlerPtr func)
{
    m_MessageHandler.insert(std::pair<long, HandlerPtr>(id, func));
}

template<class T>
LRESULT CALLBACK Dapper32::BaseWindow<T>::WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
    if(m_MessageHandlers.count(msg) == 1)
    {
        auto it = m_MessageHandlers.find(msg);
        it->second(wparam, lparam);   // <-- error here for all template instantiations
        return 0;
    }

    return DefWindowProc(hwnd, msg, wparam, lparam);
}

Here’s a little background. For fun and practice, i’m making a win32 wrapper since it seems like a fun, lengthy project to tackle. After a bit of a deliberation, i decided that i preferred a system of storing message handlers in maps rather than each message getting there own virtual function, or worse even, working with a giant switch statement. What the goal here is, you derive from this BaseWindow class and then the template parameter is that derived class. Something like

class MyWindow : public BaseWindow<MyWindow>

then you make private methods that will handle a specific message, and then call the AddHandler function passing in the message id, and then a pointer to that method. Easy as cake, and i’ve verified that they are entered into the map correctly. However, in the BaseWindow class, i get the error:

error C2064: term does not evaluate to a function taking 2 arguments

I find this odd because every place i pass around the pointer, the declaration certainly does take two arguments. When i remove the parentheses and arguements to make it look like:

it->second;

it compiles and runs, and of course, none of the handlers are called, but how can it even compile when a function pointer with two parameters is invoked without taking an arguement list? something is fishy and frankly i don’t get it. Do any of you brilliant minds have any insight into this?

Answer 1

Can’t remove the question so i guess i’ll exlain how i solved it. got rid of the method pointers altogether, used std::functions in the map, and then used std::bind in the add handler function calls. much easier to work with system and method pointers are harder to store in a map together.