指向函数的指针作为函数参数，是 C 语言实际应用中的一个比较深入的部分。
目录
一、什么是函数的指针
二、用函数指着变量调用函数
2.1举例说明
三、怎样定义和使用指向函数的指针变量
3.1定义指向函数的指针变量
3.2指向函数的指针变量详解
3.3通过指针变量调用不同的函数举例
四、用指向函数的指针作函数参数
4.1引入
4.2举例说明
一、什么是函数的指针
如果在程序中定义了一个函数，在编译时会把函数的源代码转换为可执行代码并分配一段存储空间。这段内存空间有一个起始地址，也称为函数的人口地址。每次调用函数时都从该地址入口开始执行此段函数代码。函数名代表函数的起始地址。调用函数时，从函数名得到函数的起始地址，并执行函数代码。
函数名就是函数的指针，它代表函数的起始地址。
可以定义一个指向函数的指针变量，用来存放某一函数的起始地址，这就意味着此指针变量指向该函数。例如：
int (*p)(int, int);定义 p 是一个指向函数的指针变量，它可以指向函数类型为整型且有两个整型参数的函数。此时，指针变量 p 的类型用 int(*)(int，int) 表示。
二、用函数指着变量调用函数
如果想调用一个函数，除了可以通过函数名调用以外，还可以通过指向函数的指针变量来调用该函数。
2.1举例说明
用函数求整数 a 和 b 中的大者。
（1）通过函数名调用函数
#include<stdio.h>
int main()
{
int max(int, int); //函数声明
int a, b, c;
printf("请输入两个数字：");
scanf_s("%d %d", &a, &b);
c = max(a, b); //通过函数名调用max函数
printf("a = %d,b = %d\nmax = %d", a, b, c);
return 0;
}
int max(int x, int y) //max函数
{
int z;
if (x > y)z = x;
else z = y;
return z;
}运行结果：
（2）通过指针变量调用它所指向的函数
#include<stdio.h>
int main()
{
int max(int, int); //函数声明
int a, b, c;
int (*p)(int, int); //定义指向函数的指针变量p
p = max; //使p指向max函数
printf("请输入两个数字：");
scanf_s("%d %d", &a, &b);
c = (*p)(a, b); //通过指针变量调用max函数
printf("a = %d,b = %d\nmax = %d", a, b, c);
return 0;
}
int max(int x, int y) //max函数
{
int z;
if (x > y) z = x;
else z = y;
return z;
}运行结果：
程序分析:
可以看到，程序 (1) 和 (2) 的 max函数是相同的。不同的只是在 main 函数中调用 max 函数的方法。
程序 (2) 的第 6 行 “ int(*p)(int，int); ” 用来定义 p 是一个指向函数的指针变量，最前面的 int 表示这个函数值(即函数返回的值)是整型的。最后面的括号中有两个 int，表示这个函数有两个 int 型参数。注意 *p 两侧的括号不可省略，表示 p 先与 * 结合，是指针变量，然后再与后面的 () 结合，() 表示是函数，即该指针变量不是指向一般的变量，而是指向函数。如果写成 “int *p(int，int); ” ，由于 () 优先级高于 *，它相当于 “ int* (p(int，int)) ” ，就成了声明一个 p 函数了(这个函数的返回值是指向整型变量的指针)。
赋值语句 “p=max” 的作用是将函数 max 的入口地址赋给指针变量 p。和数组名代表数组首元素地址类似，函数名代表该函数的入口地址。这样，p 就是指向函数 max 的指针变量，此时 p 和 max 都指向函数的开头。调用 *p 就是调用 max 函数。
注意：
p 是指向函数的指针变量，它只能指向函数的入口处而不可能指向函数中间的某一条指令处，因此不能用 *(p+1) 来表示函数的下一条指令。
三、怎样定义和使用指向函数的指针变量
3.1定义指向函数的指针变量
从 2.1 的已看到定义指向函数的指针变量的例子。定义指向函数的指针变量的一般形式为：
类型名（ *指针变量名 )( 函数参数表列 )；
如 “ int(*p)(int，int); ” ，这里的 “类型名” 是指函数返回值的类型。
怎样判定指针变量是指向函数的指针变量：
首先看变量名的前面有无 “ * ” 号，如* p。如果有，肯定是指针变量而不是普通变量。其次，看变量名的后面有无圆括号，内有形参的类型。如果有，就是指向函数的指针变量，这对圆括号是函数的特征。要注意的是：由于优先级的关系，“ * 指针变量名 ” 要用圆括号括起来。
3.2指向函数的指针变量详解
（1）定义指向函数的指针变量，并不意味着这个指针变量可以指向任何函数，它只能指向在定义时指定的类型的函数。如 “ int(*p)( int，int ); ” 表示指针变量 p 可以指向函数返回值为整型且有两个整型参数的函数。在程序中把哪一个函数(该函数的值是整型的且有两个整型参数)的地址赋给它，它就指向哪一个函数。在一个程序中，一个指针变量可以先后指向同类型的不同函数。
（2）如果要用指针调用函数，必须先使指针变量指向该函数。如：p=max；这就把max函数的入口地址赋给了指针变量p。
（3）在给函数指针变量赋值时，只须给出函数名而不必给出参数，例如：p=max；因为是将函数入口地址赋给 p，而不牵涉实参与形参的结合问题。如果写成 p=max( a , b )；就错了。p=max(a,b) 的作用是将调用 max 函数所得到的函数返回值赋给 p，而不是将函数入口地址赋给 p。
（4）用函数指针变量调用函数时，只须将 (*p) 代替函数名即可 ( p 为指针变量名)，在 (*p) 之后的括号中根据需要写上实参。例如：c=(*p)( a , b ) ；表示 “ 调用由 p 指向的函数，实参为a，b。得到的函数值赋给 c ”。请注意函数返回值的类型。从指针变量 p 的定义中可以知道，函数的返回值应是整型的，因此将其值赋给整型变量 c 是合法的。
（5）对指向函数的指针变量不能进行算术运算，如 p+n，p++，p-- 等运算是无意义的。
（6）用函数名调用函数，只能调用所指定的一个函数，而通过指针变量调用函数比较灵活，可以根据不同情况先后调用不同的函数。
3.3通过指针变量调用不同的函数举例
输入两个整数，然后让用户选择 1 或 2，选 1 时调用 max 函数，输出二者中的大数，选 2 时调用 min 函数，输出二者中的小数。
#include<stdio.h>
int main()
{
int max(int, int); //函数声明
int min(int, int);
int a, b, c, n;
int (*p)(int, int); //定义指向函数的指针变量p
printf("请输入两个数字：");
scanf_s("%d %d", &a, &b);
printf("请输入指向哪个函数(1为最大值，2为最小值)：");
scanf_s("%d", &n);
if (n == 1) p = max; //如输入1，指向max函数
else p = min; //如输入2，指向min函数
c = (*p)(a, b);
printf("a = %d,b = %d\n", a, b);
if (n == 1) printf("max = %d", c);
else printf("min = %d", c);
return 0;
}
int max(int x, int y) //max函数
{
int z;
if (x > y) z = x;
else z = y;
return z;
}
int min(int x, int y) //min函数
{
int z;
if (x < y) z = x;
else z = y;
return z;
}运行结果：
程序分析：
在程序中，调用函数的语句是 “c=(*p)( a , b ); ”。从这个语句本身看不出是调用哪一个函数，在程序执行过程中由用户进行选择，输入一个数字，程序根据输入的数字决定指针变量 p 指向哪一个函数，然后调用相应的函数。
这个例子比较简单，只是示意性的，但它很有实用价值。在许多应用程序中常用菜单提示输人一个数字，然后根据输入的不同值调用不同的函数，实现不同的功能，就可以用此方法。当然，也可以不用指针变量，而用 if 语句或 switch 语句进行判断，调用不同的函数。但是显然用指针变量使程序更简洁和专业。
四、用指向函数的指针作函数参数
4.1引入
指向函数的指针变量的一个重要用途是把函数的入口地址作为参数传递到其他函数。指向函数的指针可以作为函数参数，把函数的人口地址传递给形参，这样就能够在被调用的函数中使用实参函数。它的原理可以简述如下：有一个函数(假设函数名为 fun)，它有两个形参( x1 和 x2)，定义 x1 和 x2 为指向函数的指针变量。在调用函数 fun 时，实参为两个函数名 f1 和 f2，给形参传递的是函数 f1 和 f2 的入口地址。这样在函数 fun 中就可以调用 f1 和 f2 函数了。例如：
void fun(int(*x1)(int), int(*x2)(int, int)) //定义fun函数，形参是指向函数的指针变量
{
int a, b;
int i = 3, j = 5;
a = (*x1)(i); //调用f1函数，i是实参
b = (*x2)(i, j); //调用f2函数，i,j是实参
}在 fun 函数中声明形参 x1 和 x2 为指向函数的指针变量，x1 指向的函数有一个整型形参，x2 指向的函数有两个整型形参。i 和 j 是调用 f1 和 f2 函数时所要求的实参。函数 fun 的形参 x1 和 x2 (指针变量)在函数 fun 未被调用时并不占内存单元，也不指向任何函数。
在主函数调用 fun 函数时，把实参函数 f1 和 f2 的入口地址传给形参指针变量 x1 和 x2，使 x1 和 x2 指向函数 f1 和 f2。这时，在函数 fun 中，用 *x1 和 *x2 就可以调用函数 f1 和 f2。(*x1)(i) 就相当于 f1(i)，(*x2)( i , j ) 就相当于 f2( i , j )。
既然在 fun 函数中要调用 f1 和 f2 函数，为什么不直接调用 f1 和 f2 ，而要用函数指针变量呢？如果只是用到 f1 和 f2 函数，完全可以在 fun 函数中直接调用 f1 和f2，而不必设指针变量 x1 和 x2。但是，如果在每次调用 fun 函数时，要调用的函数不是固定的，这次调用 f1 和 f2，而下次要调用 f3 和 f4，第 3 次要调用的是 f5 和 f6。这时，用指针变量就比较方便了。只要在每次调用 fun 函数时给出不同的函数名作为实参即可，fun 函数不必做任何修改。这种方法是符合结构化程序设计方法原则的，是程序设计中常使用的。
4.2举例说明
输入两个整数 a 和 b，由用户输入1，2 或 3。如输入 1，程序就给出 a 和 b 中的大者，输入 2，就给出 a 和 b 中的小者，输入 3，则求 a 与 b 之和。
#include<stdio.h>
int main()
{
int max(int, int); //函数声明
int min(int, int);
int sum(int, int);
int fun(int, int, int(*p)(int, int));
int a, b, n;
printf("请输入两个数字：");
scanf_s("%d %d", &a, &b);
printf("请输入指向哪个函数(1为最大值，2为最小值，3为求和)：");
scanf_s("%d", &n);
if (n == 1) fun(a, b, max); //如输入1，调用max函数
else if (n == 2) fun(a, b, min); //如输入2，调用min函数
else fun(a, b, sum); //如输入3，调用sum函数
return 0;
}
int fun(int x, int y, int(*p)(int, int))
{
int result;
result = (*p)(x, y);
printf("%d", result);
return 0;
}
int max(int x, int y)
{
int z;
if (x > y) z = x;
else z = y;
printf("max = ");
return z;
}
int min(int x, int y)
{
int z;
if (x < y) z = x;
else z = y;
printf("min = ");
return z;
}
int sum(int x, int y)
{
int z;
z = x + y;
printf("sum = ");
return z;
}运行结果：
程序分析：
在定义 fun 函数时，在函数首部用 “ int(*p)(int , int) ” 声明形参 p 是指向函数的指针，该函数是整型函数，有两个整型形参。max，min 和 add 是已定义的 3 个函数，分别用来实现求大数、求小数和求和的功能。
当输人1 (n=2)时，调用 fun 函数，除了将 a 和 b 作为实参，将两个整数传给 fun 函数的形参 x 和 y 外，还将函数名 max 作为实参将其入口地址传送给 fun 函数中的形参 p ( p 是指向函数的指针变量)。这时，fun 函数中的 (*p)(x,y) 相当于 max(x,y)，调用 max(x,y) 就输出 a 和 b 中的大者。
若输入 2 (n=2)，调用 fun 函数时，以函数名 min 作实参，此时 fun 函数的形参 p 指向函数 min，在 fun 函数中的函数调用 (*p)(x,y) 相当于 min(x,y)。调用 min(x,y) 就输出 a 和 b 中的小者。同理,若 n=3，调用 fun 函数时，以函数名 add 作实参，fun 函数中的 (*p)(x,y) 相当于 add(x,y)，调用 add(x, y)，就输出 a 和 b 之和。
本例的思路与3.3相似，但具体做法不同。在3.3中，定义了一个指向函数的指针变量 p，根据不同情况，使 p 指向不同的函数，然后通过该指针变量调用不同的函数。本例程序没有定义指针变量，而是根据不同情况，将不同的函数名作为调用 fun 函数的实参，把函数入口地址传送给传给函数 fun 中的形参(该形参是指向函数的指针变量)，调用 fun 函数就分别执行不同的函数。
从本例可以清楚地看到，不论调用 max，min 或 add，函数 fun 都没有改变，只是改变实参函数名而已。在 fun 函数中输出 result，由于在不同的情况下调用了不同的函数，因此 result 的值是不同的。这就增加了函数使用的灵活性。
