dio.h"  
1.  
2.  
3.  
4.  func1( a ,  b)  
5. {  
6.          sum = 0.0;  
7.          length = 0.000001;  
8.          x = a;  
9.         (x < b)  
10.         {  
11.             sum += x*x*0.000001;  
12.  
13.             x+=0.000001;  
14.         }  
15.  
16.          sum;  
17. }  
18.  
19.  main()  
20. {  
21.          result = 0.0;  
22.  
23.         result = func1(0.0, 1.0);  
24.  
25.         printf(, result);  
26. } 

现在我们改写上面的代码，使用一个指向函数的指针变量来调用函数。

dio.h"  
1.  
2.  
3.  
4.  func1( a ,  b)  
5. {  
6.          sum = 0.0;  
7.          length = 0.000001;  
8.          x = a;  
9.         (x < b)  
10.         {  
11.  
12.             sum += x*x*0.000001;  
13.  
14.             x+=0.000001;  
15.         }  
16.  
17.          sum;  
18. }  
19.  
20.  main()  
21. {  
22.          result = 0.0;  
23.  
24.          (*p)(, );  
25.         p = func1;  
26.         result = (*p)(0.0, 1.0);  
27.  
28.         printf(, result);  
29. } 

关于上面的代码，有如下几点需要说明。

①语句"double (*p)(double,double);"定义p是一个指向函数的指针变量，此函数的返回值类型为double型。特别地，double (*p) ()并非是指向某一固定函数的，它仅仅表示定义了这样一个类型的变量，在程序中可以将不同的函数地址赋给它，由此它所指向的函数就会随之变化。

②(*p)两侧的括号不能省略，这样的语法意味着p先与*结合，是一个指针变量；再与后面的括号()结合，表示此指针变量指向函数而非变量。如果将*p两侧的括号去掉，则变成double *p()，这样表示的意思是函数p()的返回值类型是一个指向double型变量的指针。本书前面也介绍过因为()的优先级高于*，所以p会先与()结合，由此就声明了一个函数而非指针。

③赋值语句"p = func1;"的意思是将函数func1的入口地址（即函数中首条指令的地址）赋给指针变量p。易见，在给函数指针变量赋值时，只需要给出函数名即可，并不需要给出参数，因此如果将上面的赋值语句改写成"p = func1(0.0,1.0);"则是错误的！但是由于这里仅仅使用了函数名，而不带括号和参数，为了不让编译器将其与变量混淆，必须在使用之前进行声明，表明func1是函数名而非变量名，这样编译时它们才会被当作函数名来处理。

④在使用函数指针时，只需将(*p)替代函数名即可，但是需要在其后的括号里显式地添加实参，即使函数不传递任何参数，该括号也不可省略。

⑤数组名可以代表数组的起始地址（数组中首元素的地址），所以函数名也可以代表函数的入口地址（函数中的首条指令的地址）。但是对于指向函数的指针变量，它只能指向函数的入口处而无法指向函数中某一条具体的指令，因此对于p+n、p++等指针运算对于指向函数的指针是没有意义的。

⑥获得一个函数地址的方法与获得一个变量地址的方法一样，于是前面程序中的语句"p = func1;"也可以写作"p = &func1; "。但是，必须保证函数func1已经在某个地方被声明过了。

指向函数的指针可以获得函数的入口地址，但它并不能像操作数组一样获得函数中每一条指令的地址，这样的操作是相对受限的。但人们不禁要问，这种语法有什么用处呢？函数指针最常用的地方是作为参数传递给其他的函数。指向函数的指针也可以作为参数以实现函数地址的传递，也就是将函数名传递给形式参数。但是我们知道，在某个函数中调用另外一个函数仅仅需要在此函数中直接调用所需的函数就可以了，这是C语言所支持的非常基本的函数调用语法。如此看来，将函数指针作为参数来传递，然后在函数体中使用实在是多此一举、画蛇添足。然而，将函数指针作为参数来使用还是非常有用的，尤其当每次函数所调用的其他函数无法固定时，这就显得尤为重要了。假设有函数fun，在某次执行过程中需要调用函数func1，而下一次就需要调用函数func2，再下一次又可能调用func3。如果使用函数指针，则不必对函数fun进行修改，只需要让其每次调用函数时通过不同的函数名来作为形参传递即可。这种方法极大地增加了函数使用的灵活性，我们可以编写一个通用的函数来实现各种专用的功能，这是符合结构化程序设计思想的方法。

下面通过一个简单的示例程序来说明这种方法的应用。该例子编写了一个求定积分的通用函数，用它可以分别求得3个函数的定积分：

  的定积分，func2用于求解

 的定积分，func3用于求解

  的定积分。

dio.h"  
1.  
2.  
3.  
4.  func1( a ,  b)  
5. {  
6.          sum = 0.0;  
7.          length = 0.000001;  
8.          x = a;  
9.         (x < b)  
10.         {  
11.             sum += x*x*0.000001;  
12.  
13.             x+=0.000001;  
14.         }  
15.  
16.          sum;  
17. }  
18.  
19.  
20.  func2( a ,  b)  
21. {  
22.          sum = 0.0;  
23.          length = 0.000001;  
24.          x = a;  
25.         (x < b)  
26.         {  
27.             sum += sin(x)*0.000001;  
28.  
29.             x+=0.000001;  
30.         }  
31.  
32.          sum;  
33. }  
34.  
35.  
36.  func3( a ,  b)  
37. {  
38.          sum = 0.0;  
39.          length = 0.000001;  
40.          x = a;  
41.         (x < b)  
42.         {  
43.             sum += exp(sqrt(x))*0.000001;  
44.  
45.             x+=0.000001;  
46.         }  
47.  
48.          sum;  
49. }  
50.  
51.  intergal( a,  b,  (*fun)(, ))  
52. {  
53.          result = 0.0;  
54.         result = (*fun)(a, b);  
55.         printf(, result);  
56. }  
57.  
58.  main()  
59. {  
60.         printf();  
61.         integral(0.0, 1.0, func1);  
62.         printf();  
63.         integral(0.0, 3.141593, func2);  
64.         printf();  
65.         integral(0.0, func3);  
66. } 

完成编码后，编译并运行程序。