2. 程式人生 > >通用的類成員函式呼叫方法.

通用的類成員函式呼叫方法.

阿新 • • 發佈：2018-12-27

這個方法可以實現按照統一的介面來呼叫類成員函式,或者靜態函式和非類成員函式. 主要原理很簡單, 就是儲存類物件指標和函式指標, 需要呼叫的時候就根據類物件指標是否為空來使用不同的方式呼叫函式.


首先, 我們需要一個把成員函式指標轉化成void *的東西..(強制轉換似乎是不行的), 因為我們需要把成員函式指標儲存起來, 又不想讓使用者寫函式指標型別描述, 那隻能轉換成void*比較方便.
這裡我們使用 聯合地址轉換 的方法.

template <typename T1, typename T2>
struct _T2T{
 union {
  T1  _tv1;
  T2  _tv2;
 };
};

template <typename T1, typename T2>
inline T1 t2t( T2 tv2 )
{
 typedef struct _T2T<T1, T2> * PT2T;
 PT2T pt = (PT2T)&tv2;
 return pt->_tv1;
}

轉換方法就是 t2t<void*>( &ClassName::FuncName );

然後, 我們來構造一個可以用 this 指標和 函式指標來進行函式呼叫的東西.....這裡使用了我之前隨筆裡介紹的多引數定義巨集, 用來生成多引數的函式呼叫.

struct callfunction
{
 class nullclass{};

 template <typename TRet>
 static inline TRet callauto( void * pThis, void * pFunc ){
  if( pThis == NULL )
   return callnothis<TRet>( pFunc );
  return callwiththis<TRet>( pThis, pFunc );
 }

#define DEFINE_CALLFUNC_AUTO_WITH_PARAM( paramcount ) template <typename TRet, DP_STMP_##paramcount(typename, Tp)>\
 static inline TRet callauto( void * pThis, void * pFunc, DP_MTMP_##paramcount(Tp, p ) ){\
  if( pThis == NULL )\
   return callnothis<TRet>( pFunc, LP_SNMP_##paramcount( p ) );\
  else\
   return callwiththis<TRet>( pThis, pFunc, LP_SNMP_##paramcount( p ) );\
 }
DEFINE_CALLFUNC_AUTO_WITH_PARAM(1);
DEFINE_CALLFUNC_AUTO_WITH_PARAM(2);
DEFINE_CALLFUNC_AUTO_WITH_PARAM(3);
DEFINE_CALLFUNC_AUTO_WITH_PARAM(4);
DEFINE_CALLFUNC_AUTO_WITH_PARAM(5);
DEFINE_CALLFUNC_AUTO_WITH_PARAM(6);
DEFINE_CALLFUNC_AUTO_WITH_PARAM(7);
DEFINE_CALLFUNC_AUTO_WITH_PARAM(8);
DEFINE_CALLFUNC_AUTO_WITH_PARAM(9);
DEFINE_CALLFUNC_AUTO_WITH_PARAM(10);

 template <typename TRet>
 static inline TRet callwiththis( void * pThis, void * pFunc ){
  typedef TRet (nullclass::*funcptr)();
  return (((nullclass*)pThis)->*p2t<funcptr>(pFunc))();
 }


#define DEFINE_CALLFUNC_WITHTHIS_WITH_PARAM(paramcount) template <typename TRet, DP_STMP_##paramcount(typename, Tp)>\
 static inline TRet callwiththis( void * pThis, void * pFunc, DP_MTMP_##paramcount(Tp, p ) ){\
  typedef TRet (nullclass::*funcptr)(DP_MTMP_##paramcount(Tp, p ));\
  return (((nullclass*)pThis)->*p2t<funcptr>(pFunc))(LP_SNMP_##paramcount( p ));\
 }
DEFINE_CALLFUNC_WITHTHIS_WITH_PARAM(1);
DEFINE_CALLFUNC_WITHTHIS_WITH_PARAM(2);
DEFINE_CALLFUNC_WITHTHIS_WITH_PARAM(3);
DEFINE_CALLFUNC_WITHTHIS_WITH_PARAM(4);
DEFINE_CALLFUNC_WITHTHIS_WITH_PARAM(5);
DEFINE_CALLFUNC_WITHTHIS_WITH_PARAM(6);
DEFINE_CALLFUNC_WITHTHIS_WITH_PARAM(7);
DEFINE_CALLFUNC_WITHTHIS_WITH_PARAM(8);
DEFINE_CALLFUNC_WITHTHIS_WITH_PARAM(9);
DEFINE_CALLFUNC_WITHTHIS_WITH_PARAM(10);

 template <typename TRet>
 static inline TRet callnothis( void * pFunc ){
  typedef TRet (*funcptr)();
  return (*p2t<funcptr>(pFunc))();
 }

#define DEFINE_CALLFUNC_NOTHIS_WITH_PARAM(paramcount) template <typename TRet, DP_STMP_##paramcount(typename, Tp)>\
 static inline TRet callnothis( void * pFunc, DP_MTMP_##paramcount(Tp, p ) ){\
  typedef TRet (*funcptr)(DP_MTMP_##paramcount(Tp, p ));\
  return (*p2t<funcptr>(pFunc))(LP_SNMP_##paramcount( p ));\
 }
DEFINE_CALLFUNC_NOTHIS_WITH_PARAM(1);
DEFINE_CALLFUNC_NOTHIS_WITH_PARAM(2);
DEFINE_CALLFUNC_NOTHIS_WITH_PARAM(3);
DEFINE_CALLFUNC_NOTHIS_WITH_PARAM(4);
DEFINE_CALLFUNC_NOTHIS_WITH_PARAM(5);
DEFINE_CALLFUNC_NOTHIS_WITH_PARAM(6);
DEFINE_CALLFUNC_NOTHIS_WITH_PARAM(7);
DEFINE_CALLFUNC_NOTHIS_WITH_PARAM(8);
DEFINE_CALLFUNC_NOTHIS_WITH_PARAM(9);
DEFINE_CALLFUNC_NOTHIS_WITH_PARAM(10);
};

這裡面提供了三種呼叫方式, callauto 是根據this是否為NULL自動選擇按照類成員函式, 還是普通函式 來呼叫, callwiththis 固定按照類成員函式來呼叫, callnothis 固定按照非成員函式的方式來呼叫.
每種呼叫方式提供了10個帶引數的呼叫和1個不帶引數的呼叫. 最大支援 10個引數的成員函式呼叫, 基本上已經足夠了.

這個struct的使用方法是

callfunction::callwiththis<returntype>( objectptr, memfuncptr, params ... );

比如我們要呼叫 類CAddObject 的物件指標 pObject 的返回型別為int 名字為 add, 並且帶有兩個int型引數的成員函式, 我們只需要這樣呼叫
int result = callfunction::callwiththis<int>( pObject, t2t<void*>( &CAddObject::add ), 20, 20 );
這樣,我們就呼叫了這個函式,並且把結果儲存在result

最後, 我們來封裝一個函式呼叫的物件, 用來更方便的使用這個方法
template <typename TRet>
class CCustomCall
{
 typedef CCustomCall<TRet> TSelf;
 void * lpThis;
 void * lpFunc;
public:
 CCustomCall( const TSelf & sv ):lpThis(sv.lpThis), lpFunc(sv.lpFunc) {}
 template <typename TFunc>
 CCustomCall( void * _this, TFunc _f ):lpThis(_this){
  lpFunc = t2p<TFunc>( _f );
 }
 CCustomCall():lpThis(NULL), lpFunc(NULL){}

 TSelf & operator =( const TSelf & sv )
 {
  lpThis = sv.lpThis;
  lpFunc = sv.lpFunc;
  return (*this);
 }

#define DEFINE_CALL_WITH_PARAM(paramcount) template <DP_STMP_##paramcount( typename, Tp ) >\
 TRet call( DP_MTMP_##paramcount(Tp, p ) ){\
  return callfunction::callauto<TRet>( lpThis, lpFunc, LP_SNMP_##paramcount(p));\
 }
 DEFINE_CALL_WITH_PARAM(1);
 DEFINE_CALL_WITH_PARAM(2);
 DEFINE_CALL_WITH_PARAM(3);
 DEFINE_CALL_WITH_PARAM(4);
 DEFINE_CALL_WITH_PARAM(5);
 DEFINE_CALL_WITH_PARAM(6);
 DEFINE_CALL_WITH_PARAM(7);
 DEFINE_CALL_WITH_PARAM(8);
 DEFINE_CALL_WITH_PARAM(9);
 DEFINE_CALL_WITH_PARAM(10);
 TRet call(){return callfunction::callauto<TRet>( lpThis, lpFunc );}
bool empty(){ return (lpFunc == NULL);}
};

使用這個類, 就可以用簡單的寫法來實現呼叫各種函式...

比如下面演示了使用同一個類來實現成員函式和非成員函式的混合呼叫.

typedef CCustomCall<int> IntCall;

class CTest
{
public:
    int add( int n1, int n2 ){ return (n1+n2);}
    int mul( int n1, int n2 ){ return (n1*n2);}
};

int div( int n1, int n2 ){ return (n1/n2);}

int main(int argc, char * argv[])
{
    CTest test;
    IntCall addcall( &test, &CTest::add );
    IntCall mulcall( &test, &CTest::mul );
    IntCall divcall( NULL, &div );
    int nResult = 0;
    nResult = addcall.call( 20, 20 );
    printf( "addcall result = %d\n", nResult );
    nResult = mulcall.call( 20, 20 );
    printf( "mulcall result = %d\n", nResult );
    nResult = divcall.call( 20, 20 );
    printf( "divcall result = %d\n", nResult );
    return 0;
}
輸出結果是

40
400
1

下面是一個作為事件呼叫的例子

typedef CCustomCall<void> EventCall;
class CButton
{
public:
    EventCall eventOnClick;
};

class CApplication
{
.....
    void OnOkButtonClick( CButton * pButton );
    CButton m_OkButton;
};

............................初始化事件...............
BOOL CApplication::Init(){
.....
m_OkButton.eventOnClick = EventCall( this, &CApplication::OnOkButtonClick );
...
}

............................在BUTTON的滑鼠按下事件中.........................

void CButton::OnMouseDown( int key, int x, int y )
{
    if( key == VK_LBUTTON && !eventOnClick.empty() )
        eventOnClick.call( this );               /// 呼叫了設定的事件函式, 在這個例子裡, 當this = CApplication::m_OkButton的時候, 就會呼叫 CApplication::OnOkButtonClick....
}


相關推薦

通用的類成員函式呼叫方法.

這個方法可以實現按照統一的介面來呼叫類成員函式,或者靜態函式和非類成員函式. 主要原理很簡單, 就是儲存類物件指標和函式指標, 需要呼叫的時候就根據類物件指標是否為空來使用不同的方式呼叫函式. 首先, 我們需要一個把成員函式指標轉化成void *的東西..(強制轉換似乎是不行的), 因為我們需要把成員

MFC中非類成員函式呼叫類成員函式方法

1、定義對話方塊類物件全域性變數指標 CDialog *g_pDlg，同時在初始化對話方塊時用this指標初始化此全域性變數。 2、在非類成員函式中可以使用g_pDlg->成員函式名或變數名進行呼叫訪問。   假如有類A，類B兩個類。如果想在B中呼叫A的成員函式，該怎麼辦

c語言呼叫c++類成員函式的方法

最近做了一個wav格式的音訊播放器，介面部分用Qt實現，中間層程式碼使用C語言實現，這就涉及到c和c++相互呼叫的問題。 c++呼叫c語言的方法在另一篇文章中已經說明，c呼叫c++的方法現做如下介紹。 音訊播放的時候中間層程式碼需要將音訊的播放進度和狀態等資訊反饋給介面程式

php，類外函式呼叫類的成員函式的方法

有一個數據庫操作類class mySql_Class，並且已經例項化，類外函式怎樣呼叫類的成員函式，前提是不再類外函式內再次例項化類。看到網上有人說在類外函式中加global $mySql_Class;但是我試了下不行。解決辦法：$c=new mySql_Class;func

C++ 兩個包含類互相呼叫彼此的類成員變數和方法

      在編寫C++程式時，有時候我們想在一個類中呼叫另一個類中的成員變數或方法，比如：兩個類 A和B ,A包含B,一般A中呼叫B中的方法比較簡單，重點是子類B如何呼叫父類A中的成員變數或方法呢？

C++指標直接呼叫類成員函式探討

摘要 本文分析了C++程式設計中用指標呼叫“類” 成員函式時出現的問題、原因及後果，討論了一般函式指標和“類”成員函式指標的不同。得出結論： 任何指向“類”的成員函式指標，由於攜帶額外的所屬物件資訊，與一般的函式有根本的不同，不能直接用來進行函式呼叫。此外，本文給出了幾種間接呼叫類的成員函式的方法。作者所

類成員函式轉換成void (*)和靜態成員函式獲取非靜態成員變數的方法

很多第三方函式需要把函式轉換成void(*)型別，如libevent 1.4版本中的event_set函式： 如果要傳遞類成員函式給相應的函式我們應該怎樣處理呢？ 僅僅傳遞類成員函式可以嗎？ 不可以的！編譯的時候會遇到下面的錯誤： cannot convert DataWa

類中成員函式呼叫問題

虛擬函式執行時，跟指標型別沒有關係；跟作用域和虛擬函式表(new出來的物件有關)有關係；        如果有作用域，根據作用域執行(不會走虛擬函式表，直接到程式碼段找)，與new的型別和指標型別沒有關係；        如果沒有作用域關鍵詞則根據虛擬函式表（與new物件有

C++ 靜態成員函式呼叫非靜態成員函式方法

#include <stdio.h> #include <windows.h> class Class; typedef struct { Class *pClass; int x; int y; }ParaNode; class Cl

C++類成員函式做引數以及轉換呼叫

最近專案過程中由於程式碼重構，想精簡程式碼的時候發現類的成員函式重構出現了無法賦值給封裝函式作為引數的問題。有一定基礎的coder應該都知道其中有隱含this成員的原因，但在用法上網上資料雖多但沒有一個較為具體的程式範例，於是我寫下了下面一段程式碼，供大家分析參考： #in

指向類成員函式的指標並非指標

指向類成員函式的指標並非指標 參考<<C++必知必會>>的相關章節 "指向類成員函式的指標",這個術語中包含了"類成員函式"的術語,但是嚴格的說,這裡的成員函式只是指非靜態成員函式,這個術語中還包含了"指標"這個術語,但是嚴格的說,它即不包含地址,行為也不象指標,說

少說話多寫程式碼之Python學習040——類02（類的函式和方法 ）

在類裡定義函式時的self引數，其實是方法和函式的區別。在類裡定義方法時，一般都在方法里加一個預設的引數，可以是，a,c,d的。但是約定俗成就統一叫self。self表示的是 這個類的當前例項，一個類有多個例項，那麼它屬於自己所屬於的例項，不會存在例項寧缺的self會指向例項陳皮皮。 這裡比價特

常用的CPaintDC類成員函式

參考：http://blog.sina.com.cn/s/blog_50eb38e00100amhe.html 1.文字資訊顯示         BOOL TextOut（int x, int y

C++中 執行緒函式為靜態函式 及 類成員函式作為回撥函式

 執行緒函式為靜態函式： 　　執行緒控制函式和是不是靜態函式沒關係,靜態函式是在構造中分配的地址空間,只有在析構時才釋放也就是全域性的東西,不管執行緒是否執行,靜態函式的地址是不變的,並不在執行緒堆疊中static只是起了一個裝飾的作用,所以二者並沒有必然的關係 　　執行緒也是一種

類的繼承—派生類的函式呼叫分析

題目：定義一個基類BaseClass，有整型成員變數Number，構造其派生類DerivedClass，觀察建構函式和解構函式的執行情況。 程式碼如下： /*定義一個基類BaseClass，有整型成員變數Number，構造其派生類DerivedClass，觀察建構函式和解構函式的執行情況

面試題16——簡述類成員函式的重寫，過載和隱藏的區別

重寫與過載主要有以下不同： （1）範圍的區別：被重寫的和重寫的函式在兩個類中，而過載和被過載的函式在同一個類中； （2）引數的區別：被重寫函式和重寫函式的引數列表一定相同，而被過載函式和過載函式的引數列表一定不同； （3）virtual的區別：重寫的基類中被重寫的函式必須要有virtual修

模板庫排序函式呼叫方法

#include<iostream> #include<cstring> #include<stdio.h> #include<stdlib.h> // qsort head file #include<algorit

類成員函式過載與函式指標

在有成員函式過載的情況下該如何使用函式指標呢 class l { public: void func(); void func(int, int); }; void l::func() { cout << "func()" << endl; }

C++ 函式指標 指向類成員函式

//A類與B類的定義 class A { public:   void Test()   {     cout << "A::Test()" << endl;   } }; &

C++----類成員函式做友元函式

//成員函式做友元函式： //只讓visit1做building的好朋友（只有visit1能訪問building的私有屬性） class Building; class goodGay { public: goodGay(); void visit1(); void visit2();