Setting up classes to handle callback functions

Hi Guys,
so hopefully this question is going to cause less controversy around the forum than yesterday's (those of you who were there know what Im talking about )
I have been reading about callback functions - something I came across a long time ago when I copy pasted some code that used for, thoguht it was pretty magic, but didnt try and understand it. Now I am...
So here's a small program:

Code:

#include <iostream>
#include <windows.h>
using namespace std;

BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pCmdLine, int iCmdShow)
{
	EnumWindows(EnumWindowsProc, NULL);

	return 0;
}

BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{

cout << "In callback method" << endl ;


	return TRUE;
}

What Im struggling with is how to put this in a class - I mean the call back function.
If I create a class and I want to use call EnumWindows, this passes itself EnumWindowsProc. But I cant work out how to declare it within a class, so it is part of an object.
Thanks

O_o

Using ISO C callbacks with C++ class methods that need access to instance specific data requires an intermediary function to wrap the `this' pointer.

It may look like a million different things, but there is no other portable and reasonable option.

I prefer a parametric polymorphisms based approach, but virtual polymorphisms and simple "hard coding" certainly options.

[Edit]
And yes, the need for the intermediary function to deal with the `this' pointer may mean that some functions requiring such a callback can't be used with classes without jumping through bogus hoops (global state) or horrible hacks (generated thunks).
[/Edit]

[Edit]
Adapted "in place" from your example; beware of incomplete or malformed expressions.
[/Edit]

Soma

Code:

// ...

// core callback: wrapps ugly casting using whatever method you like

template
<
    typename FTarget
>
BOOL CALLBACK ClassEnumWindowsProc(HWND hwnd, LPARAM lParam)
{
    FTarget * sThis(reinterpret_cast<lParam>);
    return(OVERLOADEDEnumWindowsProc(hwnd, *sThis));
}

// ...

class MyClass;

// ...

// type (class) specific overload so we can use facilities of a clas

BOOL OVERLOADEDEnumWindowsProc(HWND hwnd, MyClass & fWhatever)
{
    // ...
    // use MyClass interface from fWhatever
    // ...
}

// ...

// and an interface for simplicity

template
<
    typename FTarget
>
BOOL MyEnumWindows(FTarget & fThis)
{
EnumWindows(&ClassEnumWindowsProc<FTarget>, &fThis);
}

// ...
// or without the wrapper
EnumWindows(&ClassEnumWindowsProc<MyClass>, ((MyClass *)(&MyClassInstance))); // verbose with intent
// ...

Any callback which isn't broken will give a way to pass a user-defined parameter into the callback. Use this parameter to pass the "this" pointer of the object you are calling back into, and use a static method to provide the callback itself. The static method will cast the user defined parameter back into an object pointer and invoke the callback (non-static) method. Any callback parameters which are needed should be held in instance variables.

If a callback does NOT provide a way to pass a user-defined parameter, then you are looking at code written by a buffoon (the creator of the callback, not you).

In the case of EnumWindows(), the parameter is provided, so you can do the right thing.

If you want to learn about this in more depth it may be worth looking through the Function Pointer Tutorials.