C++学习之普通函数指针与成员函数指针

函数指针（function pointer）是通过指向函数的指针间接调⽤函数。相信很多⼈对指向⼀般函数的函数指针使⽤的⽐较多，⽽对指向类成员函数的函数指针则⽐较陌⽣。我最近也被问到了这⽅⾯的问题，⼼中却也没有清晰的答案。故决定去查阅资料，并按照⾃⼰的思路写下这篇学习总结。

⼀、普通函数指针

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

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

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

#include#include

using namespace std;

typedef int (*pFun)(int, int); // typedef⼀个类型int add(int a, int b){ return a+b;}

int mns(int a, int b){ return a-b;}

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

int main(){

pFun pf1 = add;

cout << (*pf1)(2,3) << endl; // 调⽤add函数 pf1 = mns;

cout << (*pf1)(8,1) << endl; // 调⽤mns函数

string (*pf2)(const string&, const string&) = merge;

cout << (*pf2)(\"hello \调⽤merge函数 return 0;}

如⽰例代码，直接声明函数指针变量显得冗长⽽烦琐，所以我们可以使⽤typedef定义⾃⼰的函数指针类型。另外，函数指针还可以作为函数的形参类型，实参则可以直接使⽤函数名。

⼆、成员函数指针

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

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

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

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

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

class A;

typedef int (A::*pClassFun)(int, int); // 成员函数指针类型class A{public:

int add(int m, int n){

cout << m << \" + \" << n << \" = \" << m+n << endl; return m+n;

}

int mns(int m, int n){

cout << m << \" - \" << n << \" = \" << m-n << endl; return m-n; }

int mul(int m, int n){

cout << m << \" * \" << n << \" = \" << m*n << endl; return m*n; }

int dev(int m, int n){

cout << m << \" / \" << n << \" = \" << m/n << endl; return m/n; }

int call(pClassFun fun, int m, int n){ // 类内部接⼝ return (this->*fun)(m, n); }};

int call(A obj, pClassFun fun, int m, int n){ // 类外部接⼝ return (obj.*fun)(m, n);}

int main(){ A a;

cout << \"member function 'call':\" << endl; a.call(&A::add, 8, 4); a.call(&A::mns, 8, 4); a.call(&A::mul, 8, 4); a.call(&A::dev, 8, 4);

cout << \"external function 'call':\" << endl; call(a, &A::add, 9, 3); call(a, &A::mns, 9, 3); call(a, &A::mul, 9, 3); call(a, &A::dev, 9, 3); return 0;}

如⽰例所⽰，我们⼀样可以使⽤typedef定义成员函数指针的类型别名。另外，我们需要留意函数指针的使⽤⽅法：对于普通函数指针，是这样使⽤(*pf)(arguments)，因为要调⽤函数，必须先解引⽤函数指针，⽽函数调⽤运算符()的优先级较⾼，所以(*pf)的括号必不可少；对于成员函数指针，唯⼀的不同是需要在某⼀对象上调⽤函数，所以只需要加上成员访问符即可：

(obj.*pf)(arguments) // obj 是对象

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

三、函数表驱动

对于普通函数指针和指向成员函数的指针来说，⼀种常见的⽤法就是将其存⼊⼀个函数表（function table）当中。当程序需要执⾏某个特定的函数时，就从表中查找对应的函数指针，⽤该指针来调⽤相应的程序代码，这个就是函数指针在表驱动法中的应⽤。

表驱动法（Table-Driven Approach）就是⽤查表的⽅法获取信息。通常，在数据不多时可⽤逻辑判断语句（if…else或switch…case）来获取信息；但随着数据的增多，逻辑语句会越来越长，此时表驱动法的优势就体现出来了。

#include#include#include

using namespace std;

class A;

typedef int (A::*pClassFun)(int, int);

class A{public:

A(){ // 构造函数，初始化表 table[\"+\"] = &A::add; table[\"-\"] = &A::mns; table[\"*\"] = &A::mul; table[\"/\"] = &A::dev; }

int add(int m, int n){

cout << m << \" + \" << n << \" = \" << m+n << endl; return m+n; }

int mns(int m, int n){

cout << m << \" - \" << n << \" = \" << m-n << endl; return m-n; }

int mul(int m, int n){

cout << m << \" * \" << n << \" = \" << m*n << endl; return m*n; }

int dev(int m, int n){

cout << m << \" / \" << n << \" = \" << m/n << endl; return m/n; }

// 查找表，调⽤相应函数 int call(string s, int m, int n){ return (this->*table[s])(m, n); }

private:

map table; // 函数表};

// 测试int main(){ A a;

a.call(\"+\ a.call(\"-\ a.call(\"*\ a.call(\"/\ return 0;}

上⾯是⼀个⽰例，⽰例中的“表”通过map来实现（当然也可以使⽤数组）。表驱动法使⽤时需要注意：⼀是如何查表，从表中读取正确的数据；⼆是表⾥存放什么，如数值或函数指针。