C++中普通函数指针与类成员函数指针的异同

函数指针（function pointer）

与普通的指针一样，函数指针也是指针，但是不同的是函数指针指向的不是类型，而是函数地址。函数指针是通过指向函数的指针间接调用函数。相信很多人对指向一般函数的函数指针使用的比较多，而对指向类成员函数的函数指针则比较陌生。

普通函数指针

通常我们所说的 函数指针 指的是指向一般普通函数的指针。和其他指针一样，函数指针指向某种特定类型，
所有被同一指针运用的函数必须具有相同的形参类型和返回类型。

int (*pf)(int, int);   // 声明函数指针   

这里，pf指向的函数类型是int (int, int)，即函数的参数是两个int型，返回值也是int型。
注：pf两端的括号必不可少，如果不写这对括号，则pf是一个返回值为int* 的函数。

下面来看个例子：

namespace part1 {
typedef int (*pFun)(int, int);

int add(int a, int b) {
  return a + b;
}

string my_merge(const string& s1, const string& s2) {
  return s1 + s2;
}

void test() {
  pFun pf1 = add;
  cout << (*pf1)(2, 3) << endl;
  string (*pf2)(const string&, const string&) = my_merge;
  cout << (*pf2)("hello ", "world") << endl;
  // 下面两个输出一样：
  //0x1093e8ae0
  //0x1093e8ae0
  cout << reinterpret_cast<void*>(add) << endl;
  cout << reinterpret_cast<void*>(&add) << endl;

}
}  // namespace part1

如示例代码，直接声明函数指针变量显得冗长而烦琐，所以我们可以使用typedef定义自己的函数指针类型。
同时上面我有一个好奇的点，就是当我们：
pFun pf1 = add;的时候，为什么是这样？
经过查阅资料，发现这个这是一个省略的写法，也就是本来是这样的：
pFun pf1 = &add;
我画个图解释一下：
这是pf1 = add;的情况

下面这是pf1 = &add;的情况：

成员函数指针（重点）

成员函数指针（member function pointer）
是指可以指向类的非静态成员函数（non-static member function）的指针。类的静态成员不属于任何对象，因此无须特殊的指向静态成员的指针，指向静态成员的指针与普通指针没有什么区别。
与普通函数指针不同的是，
成员函数指针不仅要指定目标函数的形参列表和返回类型，**还必须指出成员函数所属的类。**因此，我们必须在*之前添加classname::以表示当前定义的指针指向classname的成员函树， 如下：

int (A::*pf)(int, int);	// 声明一个成员函数指针

同理，这里A::*pf两端的括号也是必不可少的，如果没有这对括号，则pf是一个返回A类数据成员（int型）指针的函数。
注意：和普通函数指针不同的是，在成员函数和指向该成员的指针之间不存在自动转换规则。

pf = &A::add; // 正确：必须显式地使用取址运算符（&）
pf = A::add; // 错误

当我们初始化一个成员函数指针时，其指向了类的某个成员函数，但并没有指定该成员所属的对象——直到使用成员函数指针时，才提供成员所属的对象。
下面是一个成员函数指针的使用示例：

namespace part2 {
class A;
typedef int (A::*pClassFun)(int, int);  // 成员函数指针类型
class A {
 public:
  int add(int a, int b) {
    return a + b;
  }
  static int sub(int a, int b) {
    return a - b;
  }
};

void test() {
  // 绑定时不要类的对象
  pClassFun pcf1 = &A::add;  // 这里一定要加取地符，至于为什么，我也不知道
  // 如果不加的话，会出现：error: call to non-static member function without an object argument
  // 个人猜测是，没加前编译器会把这个语法默认调用为函数，加了地址后就不会去调用了
  A a;
  cout << (a.*pcf1)(10, 20) << endl;  // 30
  A* b = new A;
  cout << (b->*pcf1)(30, 30) << endl;  // 60

  // ----------------------------------------
  // 类静态成员函数
  typedef int (*pF)(int, int);  // 不用加类
  pF pf = &A::sub;
  cout << (*pf)(20, 2) << endl;  // 18
}
}   // namespace part2

如示例所示，我们一样可以使用typedef定义成员函数指针的类型别名。
另外， 我们需要留意函数指针的使用方法：

• 对于普通函数指针，是这样使用(*pf)(arguments)，因为要调用函数，必须先解引用函数指针，而函数调用运算符()的优先级较高，所以(*pf)的括号必不可少；
• 对于成员函数指针，唯一的不同是需要在某一对象上调用函数，所以只需要加上成员访问符即可：

 (obj.*pf)(arguments)         // obj 是对象  
 (objptr->*pf)(arguments)     // objptr是对象指针 

(完）