这篇文章主要介绍了C++普通函数指针与成员函数指针,很重要的知识点,需要的朋友可以参考下

 

C++的函数指针（function pointer）是通过指向函数的指针间接调用函数。相信很多人对指向一般函数的函数指针使用的比较多，而对指向类成员函数的函数指针则比较陌生。本文即对C++普通函数指针与成员函数指针进行实例解析。

一、普通函数指针

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

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

这里，pf指向的函数类型是int (int, int)，即函数的参数是两个int型，返回值也是int型。

注：*pf两端的括号必不可少，如果不写这对括号，则pf是一个返回值为int指针的函数。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#include<iostream> #include<string> 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 " , "world" ) << endl; // 调用merge函数    return 0; }

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

二、成员函数指针

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

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

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

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)的括号必不可少；对于成员函数指针，唯一的不同是需要在某一对象上调用函数，所以只需要加上成员访问符即可：

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

三、函数表驱动

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

#include<iostream> #include<string> #include<map> 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<string, pClassFun> table; // 函数表 };    // 测试 int main() {    A a;    a.call( "+" , 8, 2);    a.call( "-" , 8, 2);    a.call( "*" , 8, 2);    a.call( "/" , 8, 2);    return 0; }

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