Compiler Error with Classes

Hey,

I get this error when I compile the following code:

Code:

---

1>c:\users\******\desktop\macrokeys 4\macrokeys 4\keyboardhook.cpp(12) : error C2440: 'type cast' : cannot convert from 'overloaded-function' to 'HOOKPROC'

---

Here's the keyboardhook.h source:

Code:

---

#ifndef GUARD_KEYBOARDHOOK_H
#define GUARD_KEYBOARDHOOK_H

#include <windows.h>
#include <vector>

using std::vector;

class CKeyboardHook
{
public:
        (LRESULT CALLBACK) HookProc ( int nCode, WPARAM wParam, LPARAM lParam );

        vector<int> keysDown;
        vector<int> keysToStop;

        HINSTANCE hExe;
        HHOOK hHook;

        bool keyIsDown ( int vkey );
        void stopKey ( int vkey );
        void resumeKey ( int vkey );

        void initHook();
        void killHook();
} kbHook;

#endif

---

Here is the code for keyboardhook.cpp

Code:

---

#include "stdafx.h"
#include "keyboardhook.h"

LRESULT CALLBACK CKeyboardHook::HookProc ( int nCode, WPARAM wParam, LPARAM lParam )
{
        return CallNextHookEx(kbHook.hHook, nCode, wParam, lParam);
}

void CKeyboardHook::initHook()
{
        hExe = GetModuleHandle ( NULL );
        hHook = SetWindowsHookEx ( WH_KEYBOARD_LL, (HOOKPROC)HookProc, hExe, NULL ); //This line gives the error
}

void CKeyboardHook::killHook()
{
        UnhookWindowsHookEx(hHook);
}

bool CKeyboardHook::keyIsDown(int vkey)
{
        for ( vector<int>::iterator i = keysDown.begin(); i != keysDown.end(); ++i )
        {
                if ( vkey == *i )
                        return true;
        }

        return false;
}

void CKeyboardHook::stopKey ( int vkey )
{
        for ( vector<int>::iterator i = keysToStop.begin(); i != keysToStop.end(); ++i )
        {
                if ( vkey == *i )
                        return;
        }

        keysToStop.push_back ( vkey );
}

void CKeyboardHook::resumeKey ( int vkey )
{
        for ( vector<int>::iterator i = keysToStop.begin(); i != keysToStop.end(); ++i )
        {
                if ( vkey == *i )
                {
                        keysToStop.erase ( i );
                        return;
                }
        }
}

---

Any help towards this problem would be greatly appreciated.

Thanks in advance,

Matt

You are trying to pass a member function, which has a hidden parameter of type CKeyboardHook*.

You might try a static or a free function, but that wouldn't allow it to access non-static members of CKeyboardHook...

You are trying to cast a class member function into a non-member function. That is not allowed in C++. A class member function takes a hidden parameter "this", which normal functions don't. [The hidden "this" points to the current instance of the class, and it is what allows you to do *this or this->x inside your member functions]

Since code that is non-C++ [such as the Windows kernel code] don't even understand the hidden parameter, you can't do that with the best will in the world.

It is a bit tricky to solve this sort of problem generically, but one solution that would work in this particular case, as I presume you are not going to log keys several times in the same macro recorder. So we can use a global variable that is the instance of CKeyboardHook.

Then you can have a static member function that knows about the global variable, something like this:

Code:

---

class CKeyboardHook
{
public:
        static (LRESULT CALLBACK) HookProc ( int nCode, WPARAM wParam, LPARAM lParam );
        int DoHookProcessing( int nCode, WPARAM wParam, LPARAM lParam )
...
CKeyboardHook hook;
LRESULT CALLBACK CKeyboardHook::HookProc ( int nCode, WPARAM wParam, LPARAM lParam )
{
        if (hook.DoHookProcessing( nCode, wParam, lParam ) > 0)
            ... do some stuff

        return CallNextHookEx(kbHook.hHook, nCode, wParam, lParam);
}

---

--
Mats

Thanks for the replies, guies.

That last bit of code looks like it should work just fine for me.

Thanks!

Actually, is there any possible of doing this without using globals? (I'm getting linker errors with this)

Is the only way to make everything in the class static?

Err:

Code:

---

error C2352: 'CKeyboardHook::hookProcess' : illegal call of non-static member function

---

Updated Code

keyboardhook.h

Code:

---

#ifndef GUARD_KEYBOARDHOOK_H
#define GUARD_KEYBOARDHOOK_H

#define CALL_NEXT_HOOK 1
#define DROP_NEXT_HOOK 2

#include <windows.h>
#include <vector>

using std::vector;

class CKeyboardHook
{
public:
        int hookProcess ( int nCode, WPARAM wParam, LPARAM lParam );

        static LRESULT CALLBACK LLKeyboardHook ( int nCode, WPARAM wParam, LPARAM lParam );

        vector<DWORD> keysDown;
        vector<DWORD> keysToStop;

        HINSTANCE hExe;
        static HHOOK hHook;

        bool keyIsDown ( int vkey );
        void stopKey ( int vkey );
        void resumeKey ( int vkey );

        void initHook();
        void killHook();
};

#endif

---

keyboardhook.cpp

Code:

---

#include "stdafx.h"
#include "keyboardhook.h"

LRESULT CALLBACK CKeyboardHook::LLKeyboardHook ( int nCode, WPARAM wParam, LPARAM lParam )
{
        if ( hookProcess ( nCode, wParam, lParam ) == CALL_NEXT_HOOK )
        {
                return CallNextHookEx( hHook, nCode, wParam, lParam);
        }
        else
        {
                return TRUE;
        }
}

void CKeyboardHook::initHook()
{
        hExe = GetModuleHandle ( NULL );
        hHook = SetWindowsHookEx ( WH_KEYBOARD_LL, (HOOKPROC)LLKeyboardHook, hExe, NULL );
}

void CKeyboardHook::killHook()
{
        UnhookWindowsHookEx(hHook);
}

bool CKeyboardHook::keyIsDown(int vkey)
{
        return false;
}

void CKeyboardHook::stopKey ( int vkey )
{
}

void CKeyboardHook::resumeKey ( int vkey )
{
}

---

Quote:

---

Originally Posted by guitarist809

Actually, is there any possible of doing this without using globals?

---

It does sound like the singleton pattern is applicable here.

Quote:

---

Originally Posted by laserlight

It does sound like the singleton pattern is applicable here.

---

Yes, I agree - however, a global is also a possible solution. Yes, I know, globals are not good and all that. But a singleton is really just a global with a interface to get to it...

--
Mats

I will add another advice:
Never, ever cast a function pointer to something else unless you are really, really, really, REALLY sure you must do that.
And even then, it is possible to define functions that are much safer at implementing such a cast than an old-style C-cast.
The problem is that these casts usually hides errors. If the function address you're passing is compatible with what the function expects, then it will compile without the need of a cast.
And if it does not match and you cast, then... well, it might just compile and crash later!
The compiler is your friend, and probably knows better than you, too! Don't shut it out!