类的普通成员函数的指针

很 多朋友都知道虚函数有虚函数指针，并且存放在对象的虚函数表中，它和普通成员变量一样与对象相关，因此虚函数的指针是和对象级的。一个类的普通成员函数是 类级的，因此普通成员函数的指针也是类级的。一个类的普通成员函数的指针，少有文献提及，因为很少需要用到普通成员函数的指针。尽管如此，在一些特殊的场 合，还是有可能需要用到的。

1) 成员函数简介

在 C++ 中，成员函数的指针是个比较特殊的东西。对普通的函数指针来说，可以视为一个地址 , 在需要的时候可以任意转换并直接调用。但对成员函数来说，常规类型转换是通不过编译的，调用的时候也必须采用特殊的语法。 C++ 专门为成员指针准备了三个运算符 : "::*" 用于指针的声明，而 "->*" 和 ".*" 用来调用指针指向的函数。比如 :

#include <iostream>

using namespace std;

 

class Foo

{       

public:               

         double virtual One( long inVal );               

         double virtual Two( long inVal );

};

 

double Foo::One(long inVal)

{

         return inVal;

}

 

double Foo::Two(long inVal)

{

         return inVal;

}

 

// 定义一个指向成员函数的指针类型，这些成员函数的返回值类型应该是 double ，并且有一个 long 类型的参数。

typedef double (Foo::*PMF)(long);

 

// 定义一个以对象调用函数指针的方法，其中： obj ：调用成员函数指针的对象； pointer ：成员函数的指针。

// 注意：因为 ".*" 优先级较低，所以该符号的两端，均需加上括号

#define callmemfun(obj, pointer) ((obj).*(pointer))

 

// 定义一个以对象指针调用函数指针的方法，其中： pobj ：调用成员函数指针的对象指针； pointer ：成员函数的指针。

// 注意：因为 "->*" 优先级较低，所以该符号的两端，均需加上括号

#define pcallmemfun(pobj, pointer) ((pobj)->*(pointer))

 

int main(void)

{       

         Foo aFoo;

         // 注意：获取一个成员函数指针的语法要求很严格

         // 1. 不能使用括号，比如 PMF pmf = &(Foo::Two) 是错误的

         // 2. 必须有类限定符，如 PMF pmf = &Two 是错误的， 即使是在类定义的内部也须加上类限定符， 即 PMF pmf = &Foot::Two

         // 3. 必须使用取址符号：比如 PMF pmf = Foo::Two 是错误的，虽然普通函数指针可以这样 ( 其实对以成员函数指针，某些编

//   译器也是允许这样，但最好还是加上取址符号 ) ，应该写成 PMF pmf = &Foot::Two

         PMF pmf = &Foo::Two;                                             // 取成员函数指针

        

         double result = callmemfun(aFoo, pmf)(2);

         cout << result << endl;

 

         result = pcallmemfun(&aFoo, pmf)(3);

         cout << result << endl;

 

         return 0;

}

 

无 法将成员函数类型转换为其它任何稍有不同的类型，简单的说，每个成员函数指针都是一个独有的类型，无法转换到任何其它类型。即使两个类的定义完全相同也不 能在其对应成员函数指针之间做转换。这有点类似于结构体的类型，每个结构体都是唯一的类型，但不同的是，结构体指针的类型是可以强制转换的。有了这些特殊 的用法和严格的限制之后，类成员函数的指针实际上是变得没什么用了。这就是我们平常基本看不到代码里有 "::*", ".*" 和 "->*" 的原因。

 

2) 使用成员函数指针访问类的私有成员函数

#include <iostream>

using namespace std;

 

class Foo;

typedef double (Foo::*PMF)(long);

 

#define callmemfun(obj, pointer) ((obj).*(obj.pointer))

#define pcallmemfun(pobj, pointer) ((pobj)->*(pobj->pointer))

 

class Foo

{

public:

         PMF pmf;

         Foo()

         {

                   pmf = &Foo::Three;                                // 取得私有成员函数的指针

         }

public:               

         inline double One(long inVal)

         {

                   return inVal;

         }

         inline double Two(long inVal)

         {

                   return 2 * inVal;

         }

private:

         inline double Three(long inVal)

         {

                   cout << "this is in Three..." << endl;

                   return 3 * inVal;

         }

};

 

int main(void)

{       

         Foo aFoo;

         Foo* bFoo = new Foo;

         // 通过公有成员变量 pmf ，很轻松地调用了私有成员函数 Three

         callmemfun(aFoo, aFoo.pmf)(3);

         pcallmemfun(bFoo, bFoo->pmf)(4);

 

         ((aFoo).*(aFoo.pmf))(3);

         return 0;

}