浅谈C++指针直接调用类成员函数

在编程工作中常会遇到在一个“类”中通过函数指针调用成员函数的要求，如，当在一个类中使用了C++标准库中的排序函数qsort时，因qsort参数需要一个“比较函数”指针，如果这个“类”使用某个成员函数作“比较函数”，就需要将这个成员函数的指针传给qsort供其调用。本文所讨论的用指针调用 “类”的成员函数包括以下三种情况：

网站建设哪家好，找创新互联建站！专注于网页设计、网站建设、微信开发、微信小程序定制开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了通渭免费建站欢迎大家使用！

（1）．将 “类”的成员函数指针赋予同类型非成员函数指针，如：

例子1

 
 
    
  
  
  1. #include  
    2. 
  
  
  2. typedef void (*Function1)( ); //定义一个函数指针类型。 
    3. 
  
  
  3. Function1 f1; 
    4. 
  
  
  4. class Test1 
    5. 
  
  
  5. { 
    6. 
  
  
  6. 　public:  
    7. 
  
  
  7. //…被调用的成员函数。 
    8. 
  
  
  8. void Memberfun1( ){ printf("%s \n","Calling Test3::Memberfun2 OK");}; //  
    9. 
  
  
  9. void Memberfun2() 
    10. 
  
  
  10. { 
    11. 
  
  
  11. 　f1=reinterpret_cast(Memberfun1);//将成员函数指针赋予f1。编译出错。 
    12. 
  
  
  12. 　f1(); 
    13. 
  
  
  13. } 
    14. 
  
  
  14. //… 
    15. 
  
  
  15. }; 
    16. 
  
  
  16. int main() 
    17. 
  
  
  17. { 
    18. 
  
  
  18. 　Test1 t1; 
    19. 
  
  
  19. 　t1.Memberfun2(); 
    20. 
  
  
  20. 　return 0; 
    21. 
  
  
  21. }
    22.

（2） 在一个“类”内，有标准库函数，如qsort， 或其他全局函数，用函数指针调用类的成员函数。如：

例子2：

 
 
    
  
  
  1. #include  
    2. 
  
  
  2. class Test2 
    3. 
  
  
  3. { 
    4. 
  
  
  4. private:  
    5. 
  
  
  5. int data[2];  
    6. 
  
  
  6. //… 
    7. 
  
  
  7. public: 
    8. 
  
  
  8. //… 
    9. 
  
  
  9. int __cdecl Compare(const void* elem1, const void* elem2) //成员函数。 
    10. 
  
  
  10. {  
    11. 
  
  
  11. printf("%s \n","Calling Test2::Memberfun OK"); 
    12. 
  
  
  12. return *((int*)elem1)- *((int*)elem2) ;  
    13. 
  
  
  13. } 
    14. 
  
  
  14. void Memberfun()  
    15. 
  
  
  15. {  
    16. 
  
  
  16. data[0]=2; data[1]=5; 
    17. 
  
  
  17. qsort( data, 2, sizeof(int), Compare); //标准库函数调用成 
    18. 
  
  
  18. //员函数。编译出错。 
    19. 
  
  
  19. } 
    20. 
  
  
  20. //… 
    21. 
  
  
  21. }; 
    22. 
  
  
  22. int main( ) 
    23. 
  
  
  23. { 
    24. 
  
  
  24. Test2 t2; 
    25. 
  
  
  25. t2.Memberfun(); //调用成员函数。 
    26. 
  
  
  26. return 0; 
    27. 
  
  
  27. } 
    28.

（3）同一个“类”内，一个成员函数调用另一个成员函数， 如：

例子3：

 
 
    
  
  
  1. #include "stdlib.h" 
    2. 
  
  
  2. class Test3 
    3. 
  
  
  3. { 
    4. 
  
  
  4. public: 
    5. 
  
  
  5. //… 
    6. 
  
  
  6. void Memberfun1( void (* f2)( ) ) { f2( ) ;} //成员函数1调用成员函数//2。 
    7. 
  
  
  7. void Memberfun2( ) { printf("%s \n","Calling Test3::Memberfun2 OK");} //成员函数2。 
    8. 
  
  
  8. void Memberfun3( ) { Memberfun1( Memberfun2);} // 编译出错  
    9. 
  
  
  9. //… 
    10. 
  
  
  10. }; 
    11. 
  
  
  11. int main( ) 
    12. 
  
  
  12. { 
    13. 
  
  
  13. Test3 t3; 
    14. 
  
  
  14. t3.Memberfun3(); //调用成员函数。 
    15. 
  
  
  15. return 0; 
    16. 
  
  
  16. }
    17.

以上三种情况的代码语法上没有显著的错误，在一些较早的编译环境中，如，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参数中所调用的函数类型不对。

按照以上提示，仅通过改变函数的类型无法消除错误，但是，如果单将这几个函数从类的定义中拿出来，不作任何改变就可以消除错误通过编译， 仍以第三种情况为例，以下代码可通过编译:

 
 
    
  
  
  1. #include  
    2. 
  
  
  2. void Memberfun1( void (* f2)( ) ) { f2( ) ;} //原成员函数1调用成员函数//2。 
    3. 
  
  
  3. void Memberfun2( ) { printf("%s \n","Calling Test3::Memberfun2 OK");} //原成员函数2。 
    4. 
  
  
  4. void Memberfun3( ) { Memberfun1( Memberfun2);} 
    5. 
  
  
  5. int main( ) 
    6. 
  
  
  6. { 
    7. 
  
  
  7. Memberfun3 (); 
    8. 
  
  
  8. return 0; 
    9. 
  
  
  9. }
    10.

第1、 2种情况和第3种情况完全相同。

由此可以的得出结论，以上三种情况编译不能通过的原因表面上并不在于函数类型调用不对，而是与 “类”有关。没通过编译的情况是用函数指针调用了 “类”的成员函数，通过编译的是用函数指针调用了非成员函数，而函数的类型完全相同。那么， “类”的成员函数指针和非成员函数指针有什么不同吗？

在下面的程序中，用sizeof()函数可以查看各种“类”的成员函数指针和非成员函数指针的长度（size）并输出到屏幕上。

 
 
    
  
  
  1. #include "stdafx.h" 
    2. 
  
  
  2. #include  
    3. 
  
  
  3. #include  
    4. 
  
  
  4. class Test; //一个未定义的类。 
    5. 
  
  
  5. class Test2 //一个空类。 
    6. 
  
  
  6. { 
    7. 
  
  
  7. }; 
    8. 
  
  
  8. class Test3 //一个有定义的类。 
    9. 
  
  
  9. { 
    10. 
  
  
  10. 　public: 
    11. 
  
  
  11. //... 
    12. 
  
  
  12. void (* memberfun)(); 
    13. 
  
  
  13. void Memberfun1( void (* f2)( ) ) { f2( ) ;} //成员函数1调用成员函数//2。 
    14. 
  
  
  14. void Memberfun2( );//成员函数2。 
    15. 
  
  
  15. //… 
    16. 
  
  
  16. }; 
    17. 
  
  
  17. class Test4: virtual Test3 ,Test2 //一个有virtual继承的类（derivative class）。 
    18. 
  
  
  18. { 
    19. 
  
  
  19. 　public: 
    20. 
  
  
  20. void Memberfun1( void (* f2)( ) ) { f2( ) ;}  
    21. 
  
  
  21. }; 
    22. 
  
  
  22. class Test5: Test3,Test2 //一个继承类（derivative class）。 
    23. 
  
  
  23. { 
    24. 
  
  
  24. 　public: 
    25. 
  
  
  25. void Memberfun1( void (* f2)( ) ) { f2( ) ;}  
    26. 
  
  
  26. }; 
    27. 
  
  
  27. 
  
  
  28. int main() 
    29. 
  
  
  29. { 
    30. 
  
  
  30. 　std::cout <<"一般函数指针长度= "<< sizeof(void(*)()) << '\n'; 
    31. 
  
  
  31. 　std::cout <<"-类的成员函数指针长度-"<<'\n'<<'\n'; 
    32. 
  
  
  32. 　std::cout <<"Test3类成员函数指针长度="<< sizeof(void(Test3::*)())<<'\n'<<'\n'; 
    33. 
  
  
  33. 　std::cout <<"Test5类成员函数指针长度="<
  
  
  34. 　std::cout <<"Test4类成员函数指针长度="<
  
  
  35. 　std::cout <<"Test类成员函数指针长度="<
  
  
  36. 　return 0; 
    37. 
  
  
  37. }
    38.

输出结果为（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 如下（黑体为改变之处）：

 
 
    
  
  
  1. class Test2 
    2. 
  
  
  2. { 
    3. 
  
  
  3. //…. 
    4. 
  
  
  4. int static __cdecl Compare(const void* elem1, const void* elem2) //成员函数。 
    5. 
  
  
  5. //其他不变 
    6. 
  
  
  6. }
    7.

改变后的代码编译顺利通过。原因是，static 类型的成员函数与类是分开的，其函数指针也不包含对象信息，与一般函数指针一致。这种方法虽然简便，但有两个缺点：1、被调用的函数成员定义内不能出现任何类的成员（包括变量和函数）；2、由于使用了static 成员，类在被继承时受到了限制。

（2） 使用一个函数参数含有对象信息的static 类型的成员函数为中转间接地调用其他成员函数，以例3为例，将类Test3作如下修改（黑体字为修改之处），main（）函数不变，则可顺利通过编译：

 
 
    
  
  
  1. class Test3 
    2. 
  
  
  2. { 
    3. 
  
  
  3. 　public: 
    4. 
  
  
  4. //… 
    5. 
  
  
  5. void static __cdecl Helper(Test3* test3) 
    6. 
  
  
  6. { 
    7. 
  
  
  7. 　test3->Memberfun2(); 
    8. 
  
  
  8. } 
    9. 
  
  
  9. void Memberfun1( void (* f2)(Test3*)) { f2(this) ;} //将对象信息传给Helper函数。 
    10. 
  
  
  10. void Memberfun2( ) {printf("%s \n","Calling Test3::Memberfun2 OK"); } //成员函数2。 
    11. 
  
  
  11. void Memberfun3( ) { Memberfun1( Helper);}  
    12. 
  
  
  12. //… 
    13. 
  
  
  13. };
    14.

这种间接方式对成员函数没有任何限制，克服了***种方法成员函数不能使用任何类的成员的缺点，但由于有static 成员，类的继承仍受到制约。

（3）使用一个全程函数（global function）为中转间接调用类的成员函数，仍以例3为例，将代码作如下修改（VC++6.0编译通过）：

 
 
    
  
  
  1. class Test3; 
    2. 
  
  
  2. void __cdecl Helper(Test3* test3); 
    3. 
  
  
  3. class Test3 
    4. 
  
  
  4. { 
    5. 
  
  
  5. 　public: 
    6. 
  
  
  6. //… 
    7. 
  
  
  7. void Memberfun1( void (* f2)(Test3*)) { f2(this) ;} //成员函数1调用成员函数//2。 
    8. 
  
  
  8. void Memberfun2( ) {printf("%s \n","Calling Test3::Memberfun2 OK"); } //成员函数2。 
    9. 
  
  
  9. void Memberfun3( ) { Memberfun1( Helper);}  
    10. 
  
  
  10. //… 
    11. 
  
  
  11. }; 
    12. 
  
  
  12. 
  
  
  13. void __cdecl Helper(Test3* test3) 
    14. 
  
  
  14. { 
    15. 
  
  
  15. 　test3->Memberfun2(); 
    16. 
  
  
  16. };
    17.

这个方法对成员函数没有任何要求，但是需要较多的代码。

除上述三种方法外还有其他方法，如， 可以在汇编层面上修改代码解决上述问题等，不属于本文范围。

结论：函数指针不能直接调用类的成员函数，需采取间接的方法，原因是成员函数指针与一般函数指针有根本的不同，成员函数指针除包含地址信息外，同时携带其所属对象信息。本文提供三种办法用于间接调用成员函数。这三种办法各有优缺点，适用于不同的场合。

希望通过以上内容的介绍，能够给大家带来帮助。

分享标题：浅谈C++指针直接调用类成员函数
分享链接：http://www.shufengxianlan.com/qtweb/news20/26220.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

软件开发知识

分类信息网

腾讯免备案主机　　 　重庆网站建设网络公司　　 　成都企业网站制作　　 　成都小程序商城　　 　内江智速网站建设　　 　买链接　　 　雕琢时光　　 　成都网络营销　　 　网站推广优化　　 　眉山主机托管　　 　成都品牌官网设计公司　　 　SF双层罐　　 　网站空间　　 　app制作　　 　成都标牌标识牌制作公司　　 　重庆机房托管　　 　九针服饰　　 　德阳服务器托管　　 　成都网站推广营销　　 　UI设计