I have a class:

class CFoo
{
private:
    m_data1;
    m_data2;
public:
    HRESULT         CallOutsideFunc(HWND hWnd);
    HRESULT         (WINAPI *MyCallBackFunc)(buncha params));

HRESULT CFoo::CallOutsideFunc(HWND hWnd)
{
    HRESULT result;
    result = OutsideFunc(MyCallBackFunc,(LPVOID)m_data1);
    return result;

HRESULT CFoo::*MyCallBackFunc(buncha params)
{
    do a buncha stuff...;
    return something;

This doesn't work. If I declare it this way I can access the data passed
into MyCallBackFunc but not the Class Member data of the instance that
passed it. I could also pass in a pointer to this but  OutsideFunc is
expectign a certain format and I don't have access to the code to modify it
to accept my this pointer.
My Question:
Is there a way to have a CALLBACK function in a class that is called from
outside the class?

Thanks,

Christopher White
Software Engineer
Packard Bell NEC

http://www.*-*-*.com/

If your callback is not being called through a "pointer-to-member", then the
answer is no.  You'll need to use a static member function.  According to your
code, your callback receives a bunch of params.  If not your "this" pointer,
might it receive ANYTHING which you could use to determine which CFoo instance
should process the callback?

HTH

-- Aaron [MVP]
---------------------
Aaron J Margosis

Fortress-NT - NT Workstation/Server Security Utility:
    http://www.sunbelt-software.com/fortress.htm
ScrnSaveSwitch/Plus - Screen Saver Control Utility:
    http://www.ssswitch.com

I'm guessing, but do you not want...

This lets you access the member data of the instance that invoked the
callback. The static MyCallBackFunc is just a helper to overcome the
problem that the callback should be a non-member function.
--
Ken Hagan

The typical way to do it would be:

class CFoo
{
public:
        static void RawCallback( int nFoo, LONG lUserData );
        {
                CFoo* pFoo = reinterpret_cast<CFoo*>( lUserData );
                pFoo->Callback( nFoo );
        }

        void Callback( int nFoo )
        {
                ... blah blah blah ...
        }

Do you mean that the API you're using has no provision for an "lUserData"
argument that it retains and passes to your callback?  If so, then the best
tactic depends on whether you have one CFoo object or many.

If one CFoo, just store it in some global variable g_pFoo.

class CFoo
{
...
        static void RawCallback( int nFoo, LONG lUserData );
        {
                g_pFoo->Callback( nFoo );
        }

If many CFoo objects, then RawCallback() must have _some_ argument to let
you determine the appropriate CFoo to use. (If not, the API or your
approach to using it with CFoo is flawed).  For instance, maybe it has a
"WORD wUserData" arugment, not big enough to hold a real CFoo*.  In that
case, try using a CDict< WORD, CFoo* > to lookup the appropriate CFoo*
given the WORD id.  Basically that's how MFC associates CWnd*s with HWNDs.

        Greg