VC6.0 C++ Callback Function pointer

[EagleKeeper]

Situation:

Code in File #1 (Foo) has only access to Foo2 header file (#3)
Foo2 has no knowledge of Foo.

File #1 (Foo.h)

#include "Foo2.h"
class Foo
{
Foo()
int Foo_Callback() {}
};


File #2 (Foo.cpp)

Foo *pFoo;
Foo2 *pFoo2;
LRESULT CALLBACK Foo2_Callback()
{
pFoo->Foo_Callback();
}

Foo::Foo()
{
pFoo = this;
pFoo2->CreateCallbackThread(Foo2_Callback);
}



File #3 (Foo2.h)
class Foo2
{
Foo2()
void CreateCallbackThread(LPVOID pCallbackRoutine);
};



File #4 (Foo2.cpp)
#include "Foo2.h"
static UINT Callback( LPVOID pCallbackRoutine )
{
// single pass after the thread is release
AfxGetThread()->SetThreadPriority(THREAD_PRIORITY_NORMAL);
while (true)
{
AfxGetThread()->SuspendThread();
pCallbackRoutine;
// (*pCallbackRoutine)(); // Compiler is not happy
}
}

Foo2::Foo2() {}

void Foo2::CreateCallbackThread(LPVOID pCallbackRoutine)
{
HANDLE hCallbackThread = AfxBeginThread (Callback, // static thread function
pCallbackRoutine, // parameter from Foo
THREAD_PRIORITY_ABOVE_NORMAL);
}

=======================================================

VC++6.0 Compiler will handle this code.
When executed, Callback in Foo2 skips over pCallbackRoutine.

How do I setup the pCallbackRoutine pointer to be executed in Callback

I can set an array of pointers to the function and index into the array.
The problem seems to be that pCallbackRoutine needs to be properly declared/executed as a function in Callback

 

[smack Down]

No idea the solution but is this line correct
Foo2::CreateCallbackThread(Callback);

Shouldn't Callback be Foo_CallBack?

 

[DaveSimmons]

If I'm reading this right:

The problem is the compiler only knows pCallbackRoutine is a void* so it doesn't know how to set up the stack frame for the function.

Does it only need to support a single callback signature of a pointer to void func() ?

If so, can't you cast the void* into a function pointer before calling it?

Something like:

typedef void (*voidfunction) (void);

....

((voidfunction) pCallbackRoutine)();

 

[Cooler]

Here how I would do it without any of the Microsoft libraries .

#include <cstdlib>
#include <vector>
#include <iostream>

typedef void (*voidfunction)(void);

using namespace std;
class Callback
{
private :
vector< voidfunction> list;

public :
void regesterMethod(voidfunction toadd)
{
list.push_back(toadd);
}
void callAllMethods()
{
for ( int i = 0; i < list.size(); i++)
list();
}
};
void Test1()
{
cout<<"Test1 CallBack \n";
}
void Test2()
{
cout<<"Test2 CallBack \n";
}
int main(int argc, char *argv[])
{
Callback Tester;
Tester.regesterMethod(&Test1);
Tester.regesterMethod(&Test2);
Tester.callAllMethods();
system("PAUSE");
return 0;
}

 

[dighn]

n/m was in a hurry and misread your code

 

[HigherGround]

always typedef your function pointers, even if it's only for the readers' sake

typedef LRESULT (*FooCallback)(void);

now you can cast argument into a type, which in this case is a function pointer and just call it

FooCallback callback = (FooCallback)pCallbackRoutine;
callback();

 

[EagleKeeper]

Problem has been solved using DaveSimmons and HigherGround suggestions.
Added lines are bolded. Both suggested the same thing.

Thanks guys



static UINT Callback( LPVOID pCallbackRoutine )
{
typedef void (*CallbackFunction) (void);
// single pass after the thread is release
AfxGetThread()->SetThreadPriority(THREAD_PRIORITY_NORMAL);
while (true)
{
AfxGetThread()->SuspendThread();
((CallbackFunction) pCallbackRoutine)();
}
}

 

[EagleKeeper]

Originally posted by: smack Down
No idea the solution but is this line correct
Foo2::CreateCallbackThread(Callback);

Shouldn't Callback be Foo_CallBack?

Corrected that oversight