在编程工作中常会遇到在一个“类”中通过函数指针调用成员函数的要求，如，当在一个类中使用了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函数,没有错误的
但是是否一定要这样做呢?这取决于程序员自己的选择