实例解析C++中类的成员函数指针

C语言的指针相当的灵活方便,但也相当容易出错。许多C语言初学者,甚至C语言老鸟都很容易栽倒在C语言的指针下。但不可否认的是,指针在C语言中的位置极其重要,也许可以偏激一点的来说:没有指针的C程序不是真正的C程序。
然而C++的指针却常常给我一种束手束脚的感觉。C++比C语言有更严格的静态类型,更加强调类型安全,强调编译时检查。因此,对于C语言中最容易错用的指针,更是不能放过:C++的指针被分成数据指针,数据成员指针,函数指针,成员函数指针,而且不能随便相互转换。而且这些指针的声明格式都不一样:

数据指针 T *
成员数据指针 T::*
函数指针 R (*)(...)
成员函数指针 R (T::*)(...)

还有一个更重要的区别是,指针所占的空间也不一样了。即使在32位系统中,所占的空间也有可能是4字节、8字节、12字节甚至16字节,这个依据平台及编译器,有很大的变化。
尽管C++中仍然有万能指针void*,但它却属于被批斗的对象,而且再也不能“万能”了。它不能转换成成员指针。
这样一来,C++的指针就变得很尴尬:我们需要一种指针能够指向同一类型的数据,不管这个数据是普通数据,还是成员数据;我们更需要一种指针能够指向同一类型的函数,不管这个函数是静态函数,还是成员函数。但是没有,至少从现在的C++标准中,还没有看到。
在编程工作中常会遇到在一个“类”中通过函数指针调用成员函数的要求,如,当在一个类中使用了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();
};

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

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

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

(0)

相关推荐

  • 浅谈C++ 基类指针和子类指针的相互赋值

    首先,给出基类animal和子类fish //============================================================== // animal.h // // author : zwq // describe: 非虚函数情况下,将子类指针赋给积累指针,验证最终调用 // 基类函数还是子类函数. //============================================================== #ifndef ANIMA

  • C++ 基类指针和子类指针相互赋值的实现方法

    首先,给出基类animal和子类fish //============================================================== // animal.h // // author : zwq // describe: 非虚函数情况下,将子类指针赋给积累指针,验证最终调用 // 基类函数还是子类函数. //============================================================== #ifndef ANIMA

  • C++带有指针成员的类处理方式详解

    在一个类中,如果类没有指针成员,一切方便,因为默认合成的析构函数会自动处理所有的内存.但是如果一个类带了指针成员,那么需要我们自己来写一个析构函数来管理内存.在<<c++ primer>> 中写到,如果一个类需要我们自己写析构函数,那么这个类,也会需要我们自己写拷贝构造函数和拷贝赋值函数. 析构函数: 我们这里定义一个类HasPtr,这个类中包含一个int 类型的指针.然后定义一个析构函数,这个函数打印一句话. HasPtr.h 类的头文件 #pragma once #ifndef

  • C/C++静态类和this指针详解及实例代码

     C/C++静态类和this指针详解 1.静态类 C++的静态成员不仅可以通过对象来访问,还可以直接通过类名来访问. class CBook{ public: static double price;//需要通过类外来进行初始化 } int main(void){ CBook book; book.price;//通过对象来访问 CBook::price//通过类名来访问 return 0; } 静态成员变量 对应静态成员有以下几点需要注意: (1)静态数据成员可以是当前类的类型,而其他数据成员

  • C++中指针的数据类型和运算相关知识小结

    C++有关指针的数据类型和指针运算的小结 前面已用过一些指针运算(如p++,p+i等),现在把全部的指针运算列出如下. 1) 指针变量加/减 一个整数 例如:p++,p--,p+i,p-i,p+-i,p-=i等. C++规定,一个指针变量加/减一个整数是将该指针变量的原值(是一个地址)和它指向的变量所占用的内存单元字节数相加或相减.如p+i代表这样的地址计算:p+i*d,d为p所指向的变量单元所占用的字节数.这样才能保证p+i指向p下面的第i个元素. 2) 指针变量赋值 将一个变量地址赋给一个指

  • C++获取类的成员函数的函数指针详解及实例代码

    C++获取类的成员函数的函数指针详解 用一个实际代码来说明. class A { public: staticvoid staticmember(){cout<<"static"<<endl;} //static member void nonstatic(){cout<<"nonstatic"<<endl;} //nonstatic member virtualvoid virtualmember(){cout<

  • C++指向类成员函数的指针详细解析

    首先 函数指针是指向一组同类型的函数的指针:而类成员函数我们也可以相似的认为,它是指向同类中同一组类型的成员函数的指针,当然这里的成员函数更准确的讲应该是指非静态的成员函数.前者是直接指向函数地址的,而后者我们从字面上也可以知道 它肯定是跟类和对象有着关系的. 函数指针实例: 复制代码 代码如下: typedef int (*p)(int,int);//定义一个接受两个int型且返回int型变量的函数指针类型int func(int x,int y){ printf("func:x=%d,y=%

  • 实例解析C++中类的成员函数指针

    C语言的指针相当的灵活方便,但也相当容易出错.许多C语言初学者,甚至C语言老鸟都很容易栽倒在C语言的指针下.但不可否认的是,指针在C语言中的位置极其重要,也许可以偏激一点的来说:没有指针的C程序不是真正的C程序. 然而C++的指针却常常给我一种束手束脚的感觉.C++比C语言有更严格的静态类型,更加强调类型安全,强调编译时检查.因此,对于C语言中最容易错用的指针,更是不能放过:C++的指针被分成数据指针,数据成员指针,函数指针,成员函数指针,而且不能随便相互转换.而且这些指针的声明格式都不一样:

  • C++普通函数指针与成员函数指针实例解析

    C++的函数指针(function pointer)是通过指向函数的指针间接调用函数.相信很多人对指向一般函数的函数指针使用的比较多,而对指向类成员函数的函数指针则比较陌生.本文即对C++普通函数指针与成员函数指针进行实例解析. 一.普通函数指针 通常我们所说的函数指针指的是指向一般普通函数的指针.和其他指针一样,函数指针指向某种特定类型,所有被同一指针运用的函数必须具有相同的形参类型和返回类型. int (*pf)(int, int); // 声明函数指针 这里,pf指向的函数类型是int (

  • 一般函数指针和类的成员函数指针深入解析

    函数指针是通过指向函数的指针间接调用函数.函数指针可以实现对参数类型.参数顺序.返回值都相同的函数进行封装,是多态的一种实现方式.由于类的非静态成员函数中有一个隐形的this指针,因此,类的成员函数的指针和一般函数的指针的表现形式不一样. 1.指向一般函数的指针函数指针的声明中就包括了函数的参数类型.顺序和返回值,只能把相匹配的函数地址赋值给函数指针.为了封装同类型的函数,可以把函数指针作为通用接口函数的参数,并通过函数指针来间接调用所封装的函数.下面是一个指向函数的指针使用的例子. 复制代码

  • C++中类的成员函数及内联函数使用及说明

    目录 成员函数 成员函数中出现的参数 类相关的非成员函数 自己定义的对象作为函数的形参 成员函数返回值是对象的引用 成员函数调用成员函数 内联函数 成员函数 即在类内定义的方法.通过对象名.成员函数()的方式可以调用. 一般将成员函数定义在类外,因为成员函数一般比较复杂. 简单的成员函数可以定义在类内,定义在类外的方式如下所示: 成员函数中出现的参数 对于成员函数中出现的参数,首先先在成员函数内部查找其声明,如在成员函数内没找到,则在类内寻找,类内所有权限的成员都可以被考虑,即使声明部分出现在函

  • C++中回调函数及函数指针的实例详解

    C++中回调函数及函数指针的实例详解 如何获取到类中函数指针 实现代码: //A类与B类的定义 class A { public: void Test() { cout << "A::Test()" << endl; } }; class B : public A { public: void Test() { cout << "B::Test()" << endl; } }; //定义类的成员函数指针 typedef

  • C++在成员函数中使用STL的find_if函数实例

    本文实例讲述了C++在成员函数中使用STL的find_if函数的方法.分享给大家供大家参考.具体方法分析如下: 一般来说,STL的find_if函数功能很强大,可以使用输入的函数替代等于操作符执行查找功能(这个网上有很多资料,我这里就不多说了). 比如查找一个数组中的奇数,可以用如下代码完成(具体参考这里:http://www.cplusplus.com/reference/algorithm/find_if/): #include <iostream> #include <algori

  • C++中函数指针详解及代码分享

    函数指针 函数存放在内存的代码区域内,它们同样有地址.如果我们有一个int test(int a)的函数,那么,它的地址就是函数的名字,如同数组的名字就是数组的起始地址. 1.函数指针的定义方式:data_types (*func_pointer)( data_types arg1, data_types arg2, ...,data_types argn); c语言函数指针的定义形式:返回类型 (*函数指针名称)(参数类型,参数类型,参数类型,-); c++函数指针的定义形式:返回类型 (类名

  • C++函数指针的用法详解

    目录 C++函数指针详细理解 函数指针初识 函数指针作为形参使用 函数指针作为返回值 练习 总结 C++函数指针详细理解 函数指针初识 函数指针是指向函数的指针,并不等于函数,它能够执行函数的操作,可以跟指针变量一起来理解,其基本声明格式为: type (*ptrname)(形参列表); 例子,声明一个比较两个字符串大小的函数指针 bool (*cp)(const string s1, const string s2); 需要注意的是,不要去掉括号!!!如果去掉括号,含义就变成了返回一个bool

随机推荐