修正的第三版 非静态类成员函数指针 解决方案

hyzboy

可指向任何类，包括未知类的成员函数。

仅保证Borland C++与Visual C++ 2005正常。

1. 
   
2. #include<stdio.h>
   
3. #include<stddef.h>
   
4.        
   
5. class _Object{};
   
6.        
   
7. #if defined(SetEventCall)||defined(CallEvent)||defined(DefineEvent)
   
8.     #error SetEventCall,CallEvent,DefineEvent 已经定义
   
9. #endif//
   
10.        
    
11. #ifdef __BORLANDC__
    
12.        
    
13.     #define SetEventCall(event_obj,obj,event_func)          event_obj=obj->event_func
    
14.     #define CallEvent(event_obj)                            event_obj
    
15.     #define DefineEvent(result,name,intro)                  result (__closure *name)intro
    
16.        
    
17. #else
    
18.        
    
19.     #pragma warning(disable:4311)
    
20.        
    
21.     template <typename T> struct EventFunc
    
22.     {
    
23.         unsigned __int32 this_address;
    
24.         unsigned __int32 func_address;
    
25.        
    
26.         _Object *This;
    
27.         T Func;
    
28.        
    
29.         EventFunc()
    
30.         {
    
31.             this_address=offsetof(EventFunc,This);
    
32.             this_address+=(unsigned __int32)this;
    
33.        
    
34.             func_address=offsetof(EventFunc,Func);
    
35.             func_address+=(unsigned __int32)this;
    
36.         }
    
37.     };
    
38.        
    
39.     #define SetEventCall(event_obj,obj,event_func)      {                                                           unsigned __int32 this_address=event_obj.this_address;                                                           unsigned __int32 func_address=event_obj.func_address;                                                                                                                   {                                                               __asm mov eax,this_address                                                              __asm mov ebx,obj                                                               __asm mov [eax],ebx                                                                                                                         __asm mov eax,func_address                                                              __asm mov ebx,event_func                                                                __asm mov [eax],ebx                                                         }                                                       }
    
40.        
    
41.     #define CallEvent(event_obj)                    (event_obj.This->*(event_obj.Func))             //(*(event_obj.This).*(event_obj.Func))
    
42.        
    
43.     #define DefineEvent(result,name,intro)          EventFunc<result (_Object:: *)intro> name;
    
44. #endif//__BORLANDC__
    
45.        
    
46. class Button
    
47. {
    
48. public:
    
49.        
    
50.     DefineEvent(void,OnClick,(Button *,int));           //定义事件,原型为: void OnClick(Button *,int)
    
51.        
    
52. public:
    
53.        
    
54.     Button()
    
55.     {
    
56.         printf("Button this=%p\n",this);
    
57.     }
    
58.        
    
59.     void TestButtonClick()
    
60.     {
    
61.         CallEvent(OnClick)(this,0);                     //呼叫OnClick,原型为: OnClick(this,0)
    
62.     }
    
63. };
    
64.        
    
65. class Test
    
66. {
    
67.     Button *button;
    
68.        
    
69. public:
    
70.        
    
71.     void OnButtonClick(Button *but,int)
    
72.     {
    
73.         printf("Test::OnButtonClick,this=%p,but=%p\n",this,but);
    
74.     };
    
75.        
    
76. public:
    
77.        
    
78.     Test()
    
79.     {
    
80.         printf("Test this=%p\n",this);
    
81.        
    
82.         button=new Button;
    
83.        
    
84.         SetEventCall(button->OnClick,this,OnButtonClick);               //设定button->OnClick事件的处理函数为this->OnButtonClick
    
85.        
    
86.         button->TestButtonClick();
    
87.     }
    
88. };
    
89.        
    
90. void main(int,char **)
    
91. {
    
92.     Test *test;
    
93.        
    
94. #ifdef __BORLANDC__
    
95.     printf("Compiler: Borland C/C++ or Turbo C/C++ %d.%d%d\n",(__BORLANDC__>>8),((__BORLANDC__&0xF0)>>4),(__BORLANDC__&0x0F));
    
96. #endif
    
97. #ifdef _MSC_VER
    
98.     printf("Compiler: Microsoft C/C++ %.2f (Visual C/C++ %.2f)\n",_MSC_VER/100.f,_MSC_VER/100.f-6);
    
99. #endif//
    
100.        
     
101.     printf("Compile Time: %s %s\n\n",__DATE__,__TIME__);
     
102.        
     
103.     test=new Test;
     
104.        
     
105.     delete test;
     
106. }
     

复制代码

noslopforever

顶一个，有一点，表示指针应该需要考虑一下64位指针的问题吧？毕竟64位越来越近了……用__int32会不会有点……

hyzboy

在32位编译器下指针还都是32位。

64位下将__int32改为__int64,将eax之类改为rax就可以了。

ixnehc

http://www.codeproject.com/cpp/FastDelegate.asp
codeproject上有一个fastdelegate的项目,好像做得更完善一点.

谜の名侦探

我以前用的是下面的这种方法
namespace xlibplus
{

template < class TRet, class T >
inline TRet ThisCall0( T func, LPVOID pThis )
{       
        TRet lpRet;
        __asm mov ecx, pThis;
        //__asm push eax
        __asm call dword ptr[func];
        __asm mov lpRet, eax
        return lpRet;
}

template < class TRet, class T, class Tp1 >
inline TRet ThisCall1( T func, LPVOID pThis, Tp1 lpParam1 )
{       
        TRet lpRet;
        __asm push dword ptr[lpParam1]
        __asm mov ecx, pThis;
        //__asm push eax
        __asm call dword ptr[func];
        __asm mov lpRet, eax
        return lpRet;
}

template < class TRet, class T, class Tp1, class Tp2 >
inline TRet ThisCall2( T func, LPVOID pThis, Tp1 lpParam1, Tp2 lpParam2 )
{       
        TRet lpRet;
        __asm push dword ptr[lpParam2]
        __asm push dword ptr[lpParam1]
        __asm mov ecx, pThis;
        //__asm push eax
        __asm call dword ptr[func];
        __asm mov lpRet, eax
        return lpRet;
}

template < class TRet, class T, class Tp1, class Tp2, class Tp3  >
inline TRet ThisCall3( T func, LPVOID pThis, Tp1 lpParam1, Tp2 lpParam2, Tp3 lpParam3 )
{
        TRet lpRet;
        __asm push dword ptr[lpParam3]
        __asm push dword ptr[lpParam2]
        __asm push dword ptr[lpParam1]
        __asm mov ecx, pThis;
        //__asm push eax
        __asm call dword ptr[func];
        //__asm push eax
        __asm mov lpRet, eax
        return lpRet;
}

template < class TRet, class T, class Tp1, class Tp2, class Tp3, class Tp4 >
inline TRet ThisCall4( T func, LPVOID pThis, Tp1 lpParam1, Tp2 lpParam2, Tp3 lpParam3, Tp4 lpParam4 )
{       
        TRet lpRet;
        __asm push dword ptr[lpParam4]
        __asm push dword ptr[lpParam3]
        __asm push dword ptr[lpParam2]
        __asm push dword ptr[lpParam1]
        __asm mov ecx, pThis;
        //__asm push eax
        __asm call dword ptr[func];
        __asm mov lpRet, eax
        return lpRet;
}

template < class TRet, class T, class Tp1, class Tp2, class Tp3, class Tp4, class Tp5 >
inline TRet ThisCall5( T func, LPVOID pThis, Tp1 lpParam1, Tp2 lpParam2, Tp3 lpParam3, Tp4 lpParam4, Tp5 lpParam5 )
{       
        TRet lpRet;
        __asm push dword ptr[lpParam5]
        __asm push dword ptr[lpParam4]
        __asm push dword ptr[lpParam3]
        __asm push dword ptr[lpParam2]
        __asm push dword ptr[lpParam1]
        __asm mov ecx, pThis;
        //__asm push eax
        __asm call dword ptr[func];
        __asm mov lpRet, eax
        return lpRet;
}

template < class T >
inline LPVOID        F2P( T func )
{
        __asm mov eax, dword ptr[func];
}

template< class TRet = LPVOID >
class xThisCallCustom
{
        typedef xThisCallCustom<TRet> xThisClass;
public:
        xThisCallCustom()
        {
                m_lpThis = NULL;
                m_lpFunc = NULL;
        }

        xThisCallCustom(const xThisClass & thiscall )
        {
                m_lpThis = thiscall.m_lpThis;
                m_lpFunc = thiscall.m_lpFunc;
        }

        template <class T>
        xThisCallCustom(LPVOID lpThis, T func)
        {
                m_lpThis = lpThis;
                m_lpFunc = F2P(func);
        }

        LPVOID getThisPtr()const{ return m_lpThis;}
        VOID        setThisPtr( LPVOID lpThis ){ m_lpThis = lpThis;}

        LPVOID getFuncPtr()const{ return m_lpFunc;}
        template <class T>        VOID        setFuncPtr( T func ){ m_lpFunc = F2P( func );}

        TRet call()
        {
                if( !Assigned() )return NULL;
                return ThisCall0<TRet>( m_lpFunc, m_lpThis );
        }

        template < class Tp1 >
        TRet call( Tp1 lpParam1 )
        {
                if( !Assigned() )return NULL;
                return ThisCall1<TRet>( m_lpFunc, m_lpThis, lpParam1 );
        }
        template < class Tp1, class Tp2 >
        TRet call( Tp1 lpParam1, Tp2 lpParam2 )
        {
                if( !Assigned() )return NULL;
                return ThisCall2<TRet>( m_lpFunc, m_lpThis, lpParam1, lpParam2 );
        }
        template < class Tp1, class Tp2, class Tp3 >
        TRet call( Tp1 lpParam1, Tp2 lpParam2, Tp3 lpParam3 )
        {
                if( !Assigned() )return NULL;
                //LPVOID lpRet = NULL;
                return ThisCall3<TRet>( m_lpFunc, m_lpThis, lpParam1, lpParam2, lpParam3 );
                //__asm pop lpRet;
                //return lpRet;
        }
        template < class Tp1, class Tp2, class Tp3, class Tp4 >
        TRet call( Tp1 lpParam1, Tp2 lpParam2, Tp3 lpParam3, Tp4 lpParam4 )
        {
                if( !Assigned() )return NULL;
                return ThisCall4<TRet>( m_lpFunc, m_lpThis, lpParam1, lpParam2, lpParam3, lpParam4 );
        }
        template < class Tp1, class Tp2, class Tp3, class Tp4, class Tp5 >
        TRet call( Tp1 lpParam1, Tp2 lpParam2, Tp3 lpParam3, Tp4 lpParam4, Tp5 lpParam5 )
        {
                if( !Assigned() )return NULL;
                return ThisCall5<TRet>( m_lpFunc, m_lpThis, lpParam1, lpParam2, lpParam3, lpParam4, lpParam5 );
        }

        template < class TTHIS >
        TRet callWithThis(TTHIS * pThis)
        {
                if( !Assigned() )return NULL;
                return ThisCall0<TRet>( m_lpFunc, pThis );
        }       
        template < class TTHIS, class Tp1 >
        TRet callWithThis( TTHIS * pThis, Tp1 lpParam1 )
        {
                if( !Assigned() )return NULL;
                return ThisCall1<TRet>( m_lpFunc, pThis, lpParam1 );
        }
        template < class TTHIS, class Tp1, class Tp2 >
        TRet callWithThis( TTHIS * pThis, Tp1 lpParam1, Tp2 lpParam2 )
        {
                if( !Assigned() )return NULL;
                return ThisCall2<TRet>( m_lpFunc, pThis, lpParam1, lpParam2 );
        }
        template < class TTHIS, class Tp1, class Tp2, class Tp3 >
        TRet callWithThis( TTHIS * pThis, Tp1 lpParam1, Tp2 lpParam2, Tp3 lpParam3 )
        {
                if( !Assigned() )return NULL;
                return ThisCall3<TRet>( m_lpFunc, pThis, lpParam1, lpParam2, lpParam3 );
        }
        template < class TTHIS, class Tp1, class Tp2, class Tp3, class Tp4 >
        TRet callWithThis( TTHIS * pThis, Tp1 lpParam1, Tp2 lpParam2, Tp3 lpParam3, Tp4 lpParam4 )
        {
                if( !Assigned() )return NULL;
                return ThisCall4<TRet>( m_lpFunc, pThis, lpParam1, lpParam2, lpParam3, lpParam4 );
        }
        template < class TTHIS, class Tp1, class Tp2, class Tp3, class Tp4, class Tp5 >
        TRet callWithThis( TTHIS * pThis, Tp1 lpParam1, Tp2 lpParam2, Tp3 lpParam3, Tp4 lpParam4, Tp5 lpParam5 )
        {
                if( !Assigned() )return NULL;
                return ThisCall5<TRet>( m_lpFunc, pThis, lpParam1, lpParam2, lpParam3, lpParam4, lpParam5 );
        }


        xThisClass & operator =( const xThisClass & thiscall )
        {
                this->m_lpFunc = thiscall.m_lpFunc;
                this->m_lpThis = thiscall.m_lpThis;
                return *this;
        }

        BOOL        Assigned(){ return (m_lpFunc != NULL);}
protected:
        LPVOID m_lpThis;
        LPVOID m_lpFunc;
};

typedef xThisCallCustom<> xThisCall;
typedef xThisCallCustom<> xEventCall;

typedef xThisCallCustom<int> xCompareCall;

};

谜の名侦探

针对CALLBACK的解决方案

#pragma once
template < class T >
inline LPVOID        F2P( T func )
{
        __asm mov eax, dword ptr[func];
}

class CCallbackAdapter
{
public:
        template <class T>
        CCallbackAdapter(LPVOID lpThis, T Func)
        {
                LPVOID lpFunc = F2P( Func );
                _Build( lpThis, lpFunc );
        }
        virtual ~CCallbackAdapter(void);
        template <class T>
        VOID        Build( LPVOID lpThis, T Func )
        {
                LPVOID lpFunc = F2P( Func );
                _Build( lpThis, lpFunc );
        }
        LPVOID        GetCallBack(){ return (LPVOID)m_cbCode;}
protected:
        VOID        _Build( LPVOID lpThis, LPVOID lpFunc );
        BYTE        m_cbCode[12];
};


CCallbackAdapter::~CCallbackAdapter(void)
{
}

VOID CCallbackAdapter::_Build( LPVOID lpThis, LPVOID lpFunc )
{
        m_cbCode[0] = 0xb9;
        *(LPVOID*)(m_cbCode+1) = lpThis;
        m_cbCode[5] = 0xe9;
        LONG lOffset = (LONG)lpFunc - (LONG)(&m_cbCode[10]);
        *(LONG*)(m_cbCode+6) = lOffset;
}

tt4040

和第2版有什么区别？