C语言深度解剖——读书笔记-11、指针和数组

4.7   函数指针

4.7.1    函数指针的定义

顾名思义，函数指针就是函数的指针。它是一个指针，指向一个函数。

(a)   char  *  (*fun1)(char  *p1,char  *p2);

(b)   char  * *fun2(char  *p1, char *p2);

(c)   char  * fun3 (char   *p1, char *p2);

看上面的表达式是什么意思？

(c) ：fun3是函数名， 函数的返回值为char * 类型；

(b)  ：与（c）相比唯一不同就是，函数的返回值为char **类型，是个二级指针；

(a) ：fun1是一个指针变量，它指向一个函数。这个函数有两个指针类型的参数，函数的返回值也是一个指针 ；

 

4.7.2    函数指针的使用

1. #include <stdio.h>  
2. #include <string.h>  
3. char  * fun(char * p1, char *p2)  
4. {  
5.      int  i=0;  
6.      i=strcmp(p1,p2);  
7.      if(0==i)  
8.     {  
9.          retrun p1;  
10.     }  
11.     else   
12.     {  
13.          retrun   p2;  
14.     }  
15. }  
16. int  main()  
17. {  
18.      char * (*pf)(char  *p1,char  *p2);  
19.      pf=&fun;  
20.      (*pf)("aa","bb");  
21.      retrun  0;  
22. }  

使用指针时，我么通过钥匙（“*”）来取其指向的内存里面的值，函数指针使用也如此。通过（*pf）取出存在这个地址上的函数，然后调用它。

【注意：给函数指针赋值时，可以用&fun或直接用函数名fun。这里以为函数名编译之后其实就是一个地址，所以这里两种用法没有本质的区别】

*(int *)&p ---这是什么？

void    Function()

{

     printf("Call    Function");

}

int  main()

{

     void  (*p)();

     *(int *)&p =(int )Function;

     (*p)();

     retrun  0;

}

这是什么意思？？*(int *)&p =(int )Function;  先看：

void  (*p)();    //定义了一个指针变量p，p指向了一个函数，这个函数的参数和返回值都是void;

&p  ：求指针变量p本身的地址，这是一个32位的二进制常数（32位系统）；

（int  *）&p ：表示将地址强制转换为int 类型的数据的指针；

(int )Function  ：表示将函数的入口地址强制转换成int类型的数据。

所以：*(int *)&p =(int )Function  表示将函数Function 的入口地址复制给指针变量p

(*p)() ：表示对函数Function的调用 ；

其实，函数指针和普通指针没有什么区别，只是函数指针指向的内容为函数而已。

4.7.4    函数指针数组

现我们清楚表达式   char  * (*pf)(char  *p)  定义的是一个函数指针pf , 既然pf是一个指针，那就可以存储在一个数组里。把上式修改一下：

   char   * (*pf [3]) (char  *p) ;

这是定义一个函数指针数组。它是一个数组，数组名为pf,数组内存储了3个指向函数的指针。这些指针指向一些返回值类型为指向字符的指针，参数为一个指向字符的指针的函数。

1. #include  <stdio.h>  
2.   
3. #include  <string.h>  
4.   
5. char  * fun1(char  *p)  
6.   
7. {  
8.   
9.       printf("%s\n",p);  
10.   
11.       retrun p;  
12.   
13. }  
14.   
15. char  *  fun2(char  *p)  
16.   
17. {  
18.   
19.      printf("%s\n",p);  
20.   
21.      retrun   p;  
22.   
23. }  
24.   
25. char  *fun3  (char *p)  
26.   
27. {  
28.   
29.      printf("%s\n",p);  
30.   
31.      retrun   p;  
32.   
33. }  
34.   
35. int  main()  
36.   
37. {  
38.   
39.    char  * (*pf[3])(char*p);  
40.   
41.   pf[0] = fun1;    //可以直接用函数名  
42.   
43.   pf[1] = &fun2;  //可以用函数名加上取地址符  
44.   
45.   pf[2] = &fun3;  
46.   
47.     
48.   
49.   pf[0] = ("fun1");  
50.   
51.   pf[1] = ("fun2");  
52.   
53.  pf[2] = ("fun3");  
54.   
55.  retrun  0;  
56.   
57. }  

4.7.5    函数指针数组指针

首先函数指针数组指针是一个指针，只不过这个指针指向一个数组，这个数组里面存的都是指向函数的指针。

函数指针数组指针= 函数指针数组 + 指针        即：指向数组的指针  

函数指针数组  =  函数指针  + 数组                    即：存放函数指针的数组

函数指针  =  函数  +指针                                   即：指向函数的指针

下面就定义一个简单的函数指针数组指针：

char  *(*(*pf)[3])(char  *p);

这里的pf是指针，

这个指针指向一个包含3个元素的数组

这个数组里面存储的是指向函数的指针；

下面举个例子：

[html]  view plain copy

1.  #include <stdio.h>  
2.   
3. #include <string.h>  
4.   
5. char *fun1(char  *p)  
6.   
7. {  
8.   
9.     printf("%s\n",p);  
10.   
11.     retrun  p;  
12.   
13. }  
14.   
15. char *fun2(char  *p)  
16.   
17. {  
18.   
19.     printf("%s\n",p);  
20.   
21.     retrun  p;  
22.   
23. }  
24.   
25. char *fun3(char  *p)  
26.   
27. {  
28.   
29.     printf("%s\n",p);  
30.   
31.     retrun  p;  
32.   
33. }  
34.   
35. int   main()  
36.   
37. {  
38.   
39.     char  *   (*a[3])(char  *p);  
40.   
41.     char  *   (*(*pf)[3])(char  *p);  
42.   
43.      pf  =&a;  
44.   
45.     a[0]= fun1;  
46.   
47.     a[1] =&fun2;  
48.   
49.     a[2]= &fun3;   
50.   
51.       
52.   
53.     pf[0][0]("fun1");  
54.   
55.     pf[0][1]("fun2");  
56.   
57.     pf[0][2]("fun3");  
58.   
59.      retrun  0;  
60.   
61. }