在編程工作中常會遇到在一個“類”中通過函數指針調用成員函數的要求，如，當在一個類中使用了C++標準庫中的排序函數qsort時，因qsort參數需要一個“比較函數”指針，如果這個“類”使用某個成員函數作“比較函數”，就需要將這個成員函數的指針傳給qsort供其調用。本文所討論的用指針調用 “類”的成員函數包括以下三種情況：
（1）．將 “類”的成員函數指針賦予同類型非成員函數指針，如：
例子1
#include <stdlib.h>
typedef void (*Function1)( ); //定義一個函數指針類型。
Function1 f1;
class Test1
{
public:
//…被調用的成員函數。
void Memberfun1( ){ printf("%s /n","Calling Test3::Memberfun2 OK");}; //
void Memberfun2()
{
f1=reinterpret_cast<Function1>(Memberfun1);//將成員函數指針賦予f1。編譯出錯。
f1();
}
//…
};
int main()
{
Test1 t1;
t1.Memberfun2();
return 0;
}
（2） 在一個“類”內，有標準庫函數，如qsort， 或其他全局函數，用函數指針調用類的成員函數。如：
例子2：
#include <stdlib.h>
class Test2
{
private:
int data[2];
//…
public:
//…
int __cdecl Compare(const void* elem1, const void* elem2) //成員函數。
{
printf("%s /n","Calling Test2::Memberfun OK");
return *((int*)elem1)- *((int*)elem2) ;
}
void Memberfun()
{
data[0]=2; data[1]=5;
qsort( data, 2, sizeof(int), Compare); //標準庫函數調用成
//員函數。編譯出錯。
}
//…
};
int main( )
{
Test2 t2;
t2.Memberfun(); //調用成員函數。
return 0;
}
（3）同一個“類”內，一個成員函數調用另一個成員函數， 如：
例子3：
#include "stdlib.h"
class Test3
{
public:
//…
void Memberfun1( void (* f2)( ) ) { f2( ) ;} //成員函數1調用成員函數//2。
void Memberfun2( ) { printf("%s /n","Calling Test3::Memberfun2 OK");} //成員函數2。
void Memberfun3( ) { Memberfun1( Memberfun2);} // 編譯出錯
//…
};
int main( )
{
Test3 t3;
t3.Memberfun3(); //調用成員函數。
return 0;
}
以上三種情況的代碼語法上沒有顯著的錯誤，在一些較早的編譯環境中，如，VC++ 4.0， 通常可以編譯通過，或至多給出問題提醒（Warning）。後來的編譯工具，如，VC++6.0和其他一些常用的C++編譯軟件，不能通過以上代碼的編譯， 並指出錯誤如下(以第三種情況用VC++ 6.0編譯爲例)：
error C2664: 'Memberfun1' : cannot convert parameter 1 from 'void (void)' to 'void (__cdecl *)(void)'
None of the functions with this name in scope match the target type
即：Memberfun1參數中所調用的函數類型不對。
按照以上提示，僅通過改變函數的類型無法消除錯誤，但是，如果單將這幾個函數從類的定義中拿出來，不作任何改變就可以消除錯誤通過編譯， 仍以第三種情況爲例，以下代碼可通過編譯:
#include <stdlib.h>
void Memberfun1( void (* f2)( ) ) { f2( ) ;} //原成員函數1調用成員函數//2。
void Memberfun2( ) { printf("%s /n","Calling Test3::Memberfun2 OK");} //原成員函數2。
void Memberfun3( ) { Memberfun1( Memberfun2);}
int main( )
{
Memberfun3 ();
return 0;
}
第1、 2種情況和第3種情況完全相同。
由此可以的得出結論，以上三種情況編譯不能通過的原因表面上並不在於函數類型調用不對，而是與 “類”有關。沒通過編譯的情況是用函數指針調用了 “類”的成員函數，通過編譯的是用函數指針調用了非成員函數，而函數的類型完全相同。那麼， “類”的成員函數指針和非成員函數指針有什麼不同嗎？
在下面的程序中，用sizeof()函數可以查看各種“類”的成員函數指針和非成員函數指針的長度（size）並輸出到屏幕上。
#include "stdafx.h"
#include <iostream>
#include <typeinfo.h>
class Test; //一個未定義的類。
class Test2 //一個空類。
{
};
class Test3 //一個有定義的類。
{
public:
//...
void (* memberfun)();
void Memberfun1( void (* f2)( ) ) { f2( ) ;} //成員函數1調用成員函數//2。
void Memberfun2( );//成員函數2。
//…
};
class Test4: virtual Test3 ,Test2 //一個有virtual繼承的類（derivative class）。
{
public:
void Memberfun1( void (* f2)( ) ) { f2( ) ;}
};
class Test5: Test3,Test2 //一個繼承類（derivative class）。
{
public:
void Memberfun1( void (* f2)( ) ) { f2( ) ;}
};
int main()
{
std::cout <<"一般函數指針長度= "<< sizeof(void(*)()) << '/n';
std::cout <<"-類的成員函數指針長度-"<<'/n'<<'/n';
std::cout <<"Test3類成員函數指針長度="<< sizeof(void(Test3::*)())<<'/n'<<'/n';
std::cout <<"Test5類成員函數指針長度="<<sizeof(void (Test5:: *)())<<'/n';
std::cout <<"Test4類成員函數指針長度="<<sizeof(void (Test4:: *)())<<'/n';
std::cout <<"Test類成員函數指針長度="<<sizeof(void(Test::*)()) <<'/n';
return 0;
}
輸出結果爲（VC++6.0編譯，運行於Win98操作系統，其他操作系統可能有所不同）：
一般非成員函數指針長度= 4
-類的成員函數指針長度-
Test3類成員函數指針長度=4
Test5類成員函數指針長度=8
Test4類成員函數指針長度=12
Test類成員函數指針長度=16
以上結果表明，在32位Win98操作系統中，一般函數指針的長度爲4個字節（32位），而類的成員函數指針的長度隨類的定義與否、類的繼承種類和關係而變，從無繼承關係類（Test3）的4字節（32位）到有虛繼承關係類（Virtual Inheritance）（Test4）的12字節（96位），僅有說明(declaration)沒有定義的類（Test）因爲與其有關的一些信息不明確成員函數指針最長爲16字節（128位）。顯然， 與一般函數指針不同，指向“類”的成員函數的指針不僅包含成員函數地址的信息，而且包含與類的屬性有關的信息，因此，一般函數指針和類的成員函數指針是根本不同的兩種類型，當然，也就不能用一般函數指針直接調用類的成員函數，這就是爲什麼本文開始提到的三種情況編譯出錯的原因。儘管使用較早版本的編譯軟件編譯仍然可以通過，但這會給程序留下嚴重的隱患。
至於爲什麼同樣是指向類的成員函數的指針，其長度竟然不同，從32位到128位，差別很大，由於沒有看到微軟官方的資料只能推測VC++6.0在編譯時對類的成員函數指針進行了優化，以儘量縮短指針長度，畢竟使用128位或96位指針在32位操作系統上對程序性能會有影響。但是，無論如何優化，類的成員函數指針包含一定量的對象（Objects）信息是確定的。其他的操作系統和編譯軟件是否進行了類似的處理，讀者可以用以上程序自己驗證。
那麼，當需要時，如何用指針調用類的成員函數？可以考慮以下方法：
（1） 將需要調用的成員函數設爲static 類型，如：在前述例子2中，將class Test2 成員函數Compare 定義前加上static 如下（黑體爲改變之處）：
class Test2
{
//….
int static __cdecl Compare(const void* elem1, const void* elem2) //成員函數。
//其他不變
}
改變後的代碼編譯順利通過。原因是，static 類型的成員函數與類是分開的，其函數指針也不包含對象信息，與一般函數指針一致。這種方法雖然簡便，但有兩個缺點：1、被調用的函數成員定義內不能出現任何類的成員（包括變量和函數）；2、由於使用了static 成員，類在被繼承時受到了限制。
（2） 使用一個函數參數含有對象信息的static 類型的成員函數爲中轉間接地調用其他成員函數，以例3爲例，將類Test3作如下修改（黑體字爲修改之處），main（）函數不變，則可順利通過編譯：
class Test3
{
public:
//…
void static __cdecl Helper(Test3* test3)
{
test3->Memberfun2();
}
void Memberfun1( void (* f2)(Test3*)) { f2(this) ;} //將對象信息傳給Helper函數。
void Memberfun2( ) {printf("%s /n","Calling Test3::Memberfun2 OK"); } //成員函數2。
void Memberfun3( ) { Memberfun1( Helper);}
//…
};
這種間接方式對成員函數沒有任何限制，克服了第一種方法成員函數不能使用任何類的成員的缺點，但由於有static 成員，類的繼承仍受到制約。
（3）使用一個全程函數（global function）爲中轉間接調用類的成員函數，仍以例3爲例，將代碼作如下修改（VC++6.0編譯通過）：
class Test3;
void __cdecl Helper(Test3* test3);
class Test3
{
public:
//…
void Memberfun1( void (* f2)(Test3*)) { f2(this) ;} //成員函數1調用成員函數//2。
void Memberfun2( ) {printf("%s /n","Calling Test3::Memberfun2 OK"); } //成員函數2。
void Memberfun3( ) { Memberfun1( Helper);}
//…
};
void __cdecl Helper(Test3* test3)
{
test3->Memberfun2();
};
這個方法對成員函數沒有任何要求，但是需要較多的代碼。
除上述三種方法外還有其他方法，如， 可以在彙編層面上修改代碼解決上述問題等，不屬於本文範圍。
結論：函數指針不能直接調用類的成員函數，需採取間接的方法，原因是成員函數指針與一般函數指針有根本的不同，成員函數指針除包含地址信息外，同時攜帶其所屬對象信息。本文提供三種辦法用於間接調用成員函數。這三種辦法各有優缺點，適用於不同的場合。
類對象的成員函數有時可以當作一般的 ANSI C 函數一樣處理。正如可以聲明指向對象數據成員的一般指針一樣，也可以聲明指向對象成員函數的指針，然後通過該指針間接調用該函數。請看例1：
例1 使用成員函數指針
class Example{
long value;
int time;
public:
long get_value(){return value;}
long get_time(){return time + value;}
};
int main()
{
long (Example::*fp)() = &Example::get_value;
Example e;
//間接調用 Example::get_value()
long v = (e.*fp)();
//間接調用 Example::get_time()
fp = &Example::get_time;
long t = (e.*fp)();
return 0;
}
這種表示法有點討厭。也許這就是一些程序員避免使用它的原因。指針 fp 用來調用類 Example 的兩個不同的函數。同一指針可以調用不同的成員函數，但這些成員函數必須接收同樣數目和類型的參數，返回同樣的類型的值。如果成員函數需要參數，這種指針聲明方法有些變化，如下面的例2：
例2 指向帶參數的成員函數指針
#include
class Example{
long value;
char name[30];
public:
long set_value(long v)
{
value = v;
return value;
}
long set_name(char* str)
{
strcpy(name,string);
return name;
}
};
int main()
{
long (Example::*fp)(long) = &Example::set_value;
Example e;
//間接調用 Example::set_value()
long new_value = 5;
long v = (e.*fp)(new_value);
//間接調用 Example::set_name()
char* (Example::*fp1)(char*) = &Example::set_name;
char* url ="dozb.blogchina.com";
char* new_name = (e.*fp1)(url);
new_name = (e.*fp1)("dozb");
return 0;
}
上述代碼給出了三種通過指針調用函數的方法。還有一個更大的變化：函數調用可以與對象指針連用。下面是類 Example 的例子：
int main()
{
//聲明一個對象
Example example;
//聲明一個指針指向它
Example * e = &example;
//使用指向對象的指針
long (Example::*fp)(long) = &Example::set_value;
long v = (e->*fp)(219);
return 0;
}
不管傳值還是傳地址方式，調用非靜態成員函數時都必須與具體的類的對象聯繫起來。靜態成員函數有所不同，聲明靜態成員函數指針的 方法也有不同。不能用對象或對象的指針調用靜態成員。如下面例3：
例3 指向靜態成員函數的指針
class StaticExample
{
public:
static int foo();
static int woo()(;
};
int value; //定義一個全局變量
int StaticExample::foo()
{
return value;//記住靜態成員函數不能訪問類數據成員，因爲它們沒有 this 指針
}
int StaticExample::foo()
{
return 3;
}
int main()
{
int (*fp) = &StaticExample::foo;
(*fp)();
fp = &StaticExample::woo;
(*fp)();
}
參考<<C++必知必會>>的相關章節
"指向類成員函數的指針",這個術語中包含了"類成員函數"的術語,但是嚴格的說,這裏的成員函數只是指非靜態成員函數,這個術語中還包含了"指針"這個術語,
但是嚴格的說,它即不包含地址,行爲也不象指針,說得乾脆點,那就是"指向類成員函數的指針"並非指針.儘管這個術語有很大的迷惑性,但是就其含義來說,
可以把一組同類型的函數抽象爲一個"指向函數的指針",同樣的道理,可以把一組類中同類型的類成員函數抽象爲一個"指向類成員函數的指針",兩者是一致的
"指向類成員函數的指針"和"指向函數的指針"有什麼區別?從字面上就可以清楚的知道,前者是和類,對象相關的,而後者直接指向函數的地址
我們首先複習一下"指向函數的指針"如何使用?
void print()
{
}
void (*pfun)(); //聲明一個指向函數的指針,函數的參數是void,函數的返回值是void
pfun = print; //賦值一個指向函數的指針
(*pfun)(); //使用一個指向函數的指針
比較簡單,不是嗎?爲什麼*pfun需要用()擴起來呢?因爲*的運算符優先級比()低,如果不用()就成了*(pfun())
"指向類成員函數的指針"比"指向函數的指針"就多了個類的區別:
struct CPoint
{
void plus(double x_, double y_)
{
}
void minus(double x_, double y_)
{
}
void mul(double x_, double y_)
{
}
void dev(double x_, double y_)
{
}
virtual void move(double x_, double y_)
{
}
double x;
double y;
};
void Oper(CPoint* pPoint, void (CPoint::*pfun)(double x_, double y_), int x, int y)
{
(pPoint->*pfun)(x, y);
}
struct CPoint3d : public CPoint
{
void move(double x_, double y_)
{
}
};
int main(int argc, char* argv[])
{
CPoint pt;
void (CPoint::*pfun)(double x_, double y_);
int offset = 0;
pfun = &CPoint::plus;
offset = (int&)pfun;
(pt.*pfun)(10, 10);
Oper(&pt, pfun, 10, 10);
pfun = &CPoint::minus;
offset = (int&)pfun;
(pt.*pfun)(10, 10);
Oper(&pt, pfun, 10, 10);
pfun = &CPoint::move;
offset = (int&)pfun;
(pt.*pfun)(10, 10);
Oper(&pt, pfun, 10, 10);
CPoint3d pt3d;
void (CPoint3d::*p3dfun)(double x_, double y_);
p3dfun = &CPoint3d::move;
(pt3d.*p3dfun)(10, 10);
//p3dfun = pfun; //正確
//pfun = p3dfun; //錯誤
pfun = (void (CPoint::*)(double, double))p3dfun;
Oper(&pt3d, (void (CPoint::*)(double, double))p3dfun, 10, 10);
return 0;
}
void (CPoint::*pfun)(double x_, double y_);
這裏是"指向類成員函數的指針"的聲明,就是多了CPoint::的限定
pfun = &CPoint::plus;
這裏是"指向類成員函數的指針"的賦值,在賦值的時候必須用這種靜態的方式
(pt.*pfun)(10, 10);
這裏是"指向類成員函數的指針"的使用,記住,解引用必須有實際的this指針地址,因此必須用有地址的對象pt來解引用,.*的語法有些怪異,不過我寧願把它拆解爲pt.和*pfun兩部分來理解
offset = (int&)pfun;
這裏offset=4198410,當然不同的項目,不同的編譯器這個值是不同的,由此也可以知道,"指向類成員函數的指針"確實是一個指針,其實由C++對象模型我們就應該知道這個結論了
,在C++對象模型中,成員函數是全局的,並不屬於對象
有人想用這個值嗎?或許可以用下面的代碼:
void (CPoint::*pfun2)(double x_, double y_);
memcpy(&pfun2, &offset, sizeof(int));
Oper(&pt, pfun2, 10, 10);
不過,我還是忍不住奉勸各位,儘量不要直接使用這個值,這畢竟是編譯器內部實現的細節,實在有太多的人喜歡這種黑客似的代碼並四處炫耀,真正的"指向類成員函數的指針"
的用法只應該包括聲明,賦值和解引用
pfun = &CPoint::move;
注意到這裏的move是虛函數,那麼這裏還支持虛函數的多態嗎?沒有問題,"指向類成員函數的指針"支持多態,當然了,代價是,這時候這個指針就必須擴展爲一個結構了,C++爲了
"指向類成員函數的指針"支持多態是要付出代價的
p3dfun = pfun; //正確
存在基類的"指向類成員函數的指針"到派生類的"指向類成員函數的指針"的隱式轉換,其含義無疑是說基類的成員函數佈局信息只是派生類中成員函數佈局信息的一個子集,
因此這樣的轉換應該是沒有問題的,但是反過來呢?
//pfun = p3dfun; //錯誤
不存在派生類的"指向類成員函數的指針"到基類的"指向類成員函數的指針"的隱式轉換,因爲派生類中的成員函數並不一定能夠在基類中找到
"指向類成員函數的指針"基類和派生類的關係和"指向類對象的指針"基類和派生類的關係完全相反,就"指向類成員函數的指針"的本質來說,這是合理的,但是這樣的話,
我們就無法利用公共的Oper函數了,除非...
pfun = (void (CPoint::*)(double, double))p3dfun; //強制轉換
我們做強制轉換是可以的
Oper(&pt3d, (void (CPoint::*)(double, double))p3dfun, 10, 10);
而且也只有強制轉換纔可以利用公共的Oper函數了,這裏的Oper調用的是pt3d中的move函數,沒有錯誤的
但是是否一定要這樣做呢?這取決於程序員自己的選擇