[转]C语言指针之函数指针

1.指针函数的定义

顾名思义，指针函数即返回指针的函数。其一般定义形式如下：

类型名 *函数名(函数参数表列);

其中，后缀运算符括号“()”表示这是一个函数，其前缀运算符星号“*”表示此函数为指针型函数，其函数值为指针，即它带回来的值的类型为指针，当调用这个函数后，将得到一个“指向返回值为…的指针（地址），“类型名”表示函数返回的指针指向的类型”。

“(函数参数表列)”中的括号为函数调用运算符，在调用语句中，即使函数不带参数，其参数表的一对括号也不能省略。其示例如下：

1 int *pfun(int, int);

由于“*”的优先级低于“()”的优先级，因而pfun首先和后面的“()”结合，也就意味着，pfun是一个函数。即：

int *(pfun(int, int));

接着再和前面的“*”结合，说明这个函数的返回值是一个指针。由于前面还有一个int，也就是说，pfun是一个返回值为整型指针的函数。

我们不妨来再看一看，指针函数与函数指针有什么区别？

 int (*pfun)(int, int);

通过括号强行将pfun首先与“*”结合，也就意味着，pfun是一个指针，接着与后面的“()”结合，说明该指针指向的是一个函数，然后再与前面的int结合，也就是说，该函数的返回值是int。由此可见，pfun是一个指向返回值为int的函数的指针。

虽然它们只有一个括号的差别，但是表示的意义却截然不同。函数指针的本身是一个指针，指针指向的是一个函数。指针函数的本身是一个函数，其函数的返回值是一个指针。

2. 用函数指针作为函数的返回值

在上面提到的指针函数里面，有这样一类函数，它们也返回指针型数据（地址），但是这个指针不是指向int、char之类的基本类型，而是指向函数。对于初学者，别说写出这样的函数声明，就是看到这样的写法也是一头雾水。比如,下面的语句：

int (*ff(int))(int *, int);

我们用上面介绍的方法分析一下，ff首先与后面的“()”结合，即：

int (*(ff(int)))(int *, int);                            // 用括号将ff(int)再括起来

也就意味着，ff是一个函数。

接着与前面的“*”结合，说明ff函数的返回值是一个指针。然后再与后面的“()”结合，也就是说，该指针指向的是一个函数。

这种写法确实让人非常难懂，以至于一些初学者产生误解，认为写出别人看不懂的代码才能显示自己水平高。而事实上恰好相反，能否写出通俗易懂的代码是衡量程序员是否优秀的标准。一般来说，用typedef关键字会使该声明更简单易懂。在前面我们已经见过：

int (*PF)(int *, int);

也就是说，PF是一个函数指针“变量”。当使用typedef声明后，则PF就成为了一个函数指针“类型”，即：

typedef int (*PF)(int *, int);

这样就定义了返回值的类型。然后，再用PF作为返回值来声明函数:

PF ff(int);

下面将以程序清单1为例，说明用函数指针作为函数的返回值的用法。当程序接收用户输入时，如果用户输入d，则求数组的最大值，如果输入x，则求数组的最小值，如果输入p，则求数组的平均值。

程序清单 1 求最值与平均值示例

1       #include<stdio.h>
2       #include <assert.h>
3       double GetMin(double *dbData, int iSize)               // 求最小值
4       {
5           double dbMin;
6           int i;
7      
8           assert(iSize>0);
9           dbMin=dbData[0];
10          for (i=1; i<iSize; i++){
11                if (dbMin>dbData[i]) {
12                     dbMin=dbData[i];
13                }
14          }
15          return dbMin;
16     }
17
18     double GetMax(double *dbData, int iSize)                 // 求最大值
19     {
20         double dbMax;
21         int i;
22
23         assert(iSize>0);
24         dbMax=dbData[0];
25         for (i=1; i<iSize; i++){
26             if (dbMax< dbData[i]) {
27                 dbMax=dbData[i];
28             }
29         }
30         return dbMax;
31     }
32
33     double GetAverage(double *dbData, int iSize)            // 求平均值
34     {
35         double dbSum=0;
36         int i;
37    
38         assert(iSize>0);
39         for (i=0; i<iSize; i++)
40         {
41              dbSum+=dbData[i];
42         }
43         return dbSum/iSize;
44     }
45
46     double UnKnown(double *dbData, int iSize)             // 未知算法
47     {
48         return 0;
49     }
50
51     typedef double (*PF)(double *dbData, int iSize);     // 定义函数指针类型
52     PF GetOperation(char c)                              // 根据字符得到操作类型，返回函数指针
53     {
54         switch (c)
55         {
56           case 'd':
57                     return GetMax;
58           case 'x':
59                     return GetMin;
60           case 'p':
61                     return GetAverage;
62           default:
63                     return UnKnown;
64           }
65     }
66
67     int main(void)
68     {
69          double dbData[]={3.1415926, 1.4142, -0.5,999, -313, 365};
70          int iSize=sizeof(dbData)/sizeof(dbData[0]);
71          char c;
72
73          printf("Please input the Operation :
");
74          c=getchar();
75          printf("result is %lf
", GetOperation(c)(dbData,iSize));   // 通过函数指针调用函数
76    }

上述程序中前面4个函数分别实现求最大值、最小值、平均值和未知算法，然后实现了GetOperation函数。这个函数根据字符的返回值实现上面4个函数。它是以函数指针的形式返回的，从后面的main函数的GetOperation(c)(dbData, iSize)可以看出，通过这个指针可以调用函数。

函数指针是指向函数的指针变量。因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。如前所述，C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是一致的。函数指针有两个用途：调用函数和做函数的参数。

函数指针的声明方法为：

函数类型 (标志符指针变量名) (形参列表);

注1：“函数类型”说明函数的返回类型，“(标志符指针变量名 )”中的括号不能省，若省略整体则成为一个函数说明，说明了一个返回的数据类型是指针的函数，后面的“形参列表”表示指针变量指向的函数所带的参数列表。例如：

1 int func(int x); /* 声明一个函数 */
2 int (*f) (int x); /* 声明一个函数指针 */
3 f=func; /* 将func函数的首地址赋给指针f */

赋值时函数func不带括号，也不带参数，由于func代表函数的首地址，因此经过赋值以后，指针f就指向函数func(x)的代码的首地址。

注2：函数括号中的形参可有可无，视情况而定。

下面的程序说明了函数指针调用函数的方法：

例一、

 1 #include<stdio.h>
 2 int max(int x,int y){ return(x>y?x:y); }
 3 void main()
 4 {
 5 int (*ptr)(int, int);
 6 int a,b,c;
 7 ptr=max;
 8 scanf("%d%d",&a,&b);
 9 c=(*ptr)(a,b);
10 printf("a=%d,b=%d,max=%d",a,b,c);
11 }

ptr是指向函数的指针变量，所以可把函数max()赋给ptr作为ptr的值，即把max()的入口地址赋给ptr,以后就可以用ptr来调用该函数，实际上ptr和max都指向同一个入口地址，不同就是ptr是一个指针变量，不像函数名称那样是死的，它可以指向任何函数，就看你想怎么做了。在程序中把哪个函数的地址赋给它，它就指向哪个函数。而后用指针变量调用它，因此可以先后指向不同的函数。不过注意，指向函数的指针变量没有++和--运算，用时要小心。

不过，在某些编译器中这是不能通过的。这个例子的补充如下。

应该是这样的：

1.定义函数指针类型：

typedef int (*fun_ptr)(int,int);

2.申明变量，赋值：

fun_ptr max_func=max;

也就是说，赋给函数指针的函数应该和函数指针所指的函数原型是一致的。

例二、

 1 #include<stdio.h>
 2 void FileFunc()
 3 {
 4 printf("FileFunc
");
 5 }
 6 void EditFunc()
 7 {
 8 printf("EditFunc
");
 9 }
10 void main()
11 {
12 typedef void (*funcp)();
13 funcp pfun= FileFunc;
14 pfun();
15 pfun = EditFunc;
16 pfun();　
17 }

指针函数和函数指针的区别

1,这两个概念都是简称，指针函数是指返回值是指针的函数，即本质是一个函数。我们知道函数都有返回类型（如果不返回值，则为无值型），只不过指针函数返回类型是某一类型的指针。

其定义格式如下所示：

返回类型标识符*函数名称（形式参数表）

{ 函数体}

返回类型可以是任何基本类型和复合类型。返回指针的函数的用途十分广泛。事实上，每一个函数，即使它不带有返回某种类型的指针，它本身都有一个入口地址，该地址相当于一个指针。比如函数返回一个整型值，实际上也相当于返回一个指针变量的值，不过这时的变量是函数本身而已，而整个函数相当于一个“变量”。例如下面一个返回指针函数的例子：

 1 //指针函数是指返回值是指针的函数，即本质是一个函数
 2 #include<iostream>
 3 using namespace std;
 4 int main()
 5 {
 6 float *find(float (*p)[4],int m);//查询序号为m的学生的四门课程的成绩
 7 float score[][4]={{50,51,52,55},{70,70,40,80},{77,99,88,67}};//定义成绩数组，第一维可以为变量
 8 float *pf=NULL;//定义一个指针时一定要初始化
 9 int i,m;
10 cout<<"请输入您想查询的学生的序号:";
11 cin>>m;
12 pf=find(score,m);//返回为一维数组指针，指向一个学生成绩
13 for(i=0;i<4;i++)
14 cout<<*(pf+i)<<" ";
15 cout<<endl;
16 return 0;
17 }
18 float *find(float (*p)[4],int m)
19 {
20 float *pf=NULL;
21 pf=*(p+m);//p是指向二维数组的指针，加*取一维数组的指针
22 return pf;
23 }

学生学号从0号算起，函数find()被定义为指针函数，其形参pointer是指针指向包含4个元素的一维数组的指针变量。pointer+1指向 score的第一行。*(pointer+1)指向第一行的第0个元素。pt是一个指针变量，它指向浮点型变量。main()函数中调用find()函数，将score数组的首地址传给pointer.

2,“函数指针”是指向函数的指针变量，因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。如前所述，C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上一致的。函数指针有两个用途：调用函数和做函数的参数。

关于函数指针数组的定义

关于函数指针数组的定义方法，有两种：一种是标准的方法；一种是蒙骗法。

第一种，标准方法：

{

分析：函数指针数组是一个其元素是函数指针的数组。那么也就是说，此数据结构是一个数组，且其元素是一个指向函数入口地址的指针。

根据分析：首先说明是一个数组：数组名[]

其次，要说明其元素的数据类型指针:*数组名[].

再次，要明确这每一个数组元素是指向函数入口地址的指针：函数返回值类型 (*数组名[])().请注意，这里为什么要把“*数组名[]”用括号扩起来呢？因为圆括号和数组说明符的优先级是等同的，如果不用圆括号把指针数组说明表达式扩起来，根据圆括号和方括号的结合方向，那么 *数组名[]() 说明的是什么呢？是元素返回值类型为指针的函数数组。有这样的函数数组吗？不知道。所以必须括起来，以保证数组的每一个元素是指针。

}

第二种，蒙骗法：

尽管函数不是变量，但它在内存中仍有其物理地址，该地址能够赋给指针变量。获取函数地址的方法是：用不带有括号和参数的函数名得到。

函数名相当于一个指向其函数入口指针常量。那么既然函数名是一个指针常量，那么就可以对其进行一些相应的处理，如强制类型转换。

那么我们就可以把这个地址放在一个整形指针数组中，然后作为函数指针调用即可。

完整例子：

 1 #include "stdio.h"
 2 int add1(int a1,int b1);
 3 int add2(int a2,int b2);
 4 void main()
 5 {
 6 int numa1=1,numb1=2;
 7 int numa2=2,numb2=3;
 8 int (*op[2])(int a,int b);
 9 op[0]=add1;
10 op[1]=add2;
11 printf("%d %d
",op[0](numa1,numb1),op[1](numa2,numb2));
12 }
13 int add1(int a1,int b1)
14 {
15 return a1+b1;
16 }
17 int add2(int a2,int b2)
18 {
19 return a2+b2;
20 }

为函数指针数组赋值

为函数指针数组赋值有两种方式：静态定义和动态赋值。

1. 静态定义

在定义函数指针数组的时候，已经确定了每个成员所对应的函数。例如：

void (*INTARRAY[])(void) = {Stop,Run,Jump};

从根本上讲函数指针数组依然是数组，所以和数组的定义类似，由于是静态赋值，[ ]里面的数字可以

省略。这个函数指针数组的成员有三个。

INTARRAY[1](); //执行Run函数

2. 动态赋值

也可以先定义一个函数指针数组，在需要的时候为其赋值。为了还原它本来的面目，我们先对这个执行特定类型的函数指针进行类型重定义，然后再用这个新数据类型来定义数组。如下：

1 typedef void (*INTFUN)(void); //此类型的函数指针指向的是无参、无返回值的函数。
2 INTFUN INTARRAY[32]; //定义一个函数指针数组，其每个成员为INTFUN类型的函数指针
3 INTARRAY[10] = INT_TIMER0; //为其赋值
4 INTARRAY[10](); //调用函数指针数组的第10个成员指向的函数