指针和数组

指针数组：首先它是一个数组，数组的元素都是指针，数组占多少个字节由数组本身 决定。它是“储存指针的数组”的简称。

int *p1[10];

“[]”的优先级比“*”要高。p1 先与“[]”结合，构成一个数组的定义，数组名为 p1，int* 修饰的是数组的内容，即数组的每个元素。

数组指针：首先它是一个指针，它指向一个数组。在 32 位系统下永远是占 4 个字节， 至于它指向的数组占多少字节，不知道。它是“指向数组的指针”的简称。

int  (*p2)[10];

在这里“（）”的优先级比 “[]”高， “*”号和 p2 构成一个指针的定义，指针变量名为 p2，int 修饰的是数组的内容， 即数组的每个元素。

函数指针：就是函数的指针。

A) char* (*fun1)(char* p1,char* p2);
B) char* *fun2(char* p1,char* p2);
C) char* fun3(char* p1,char* p2);

A) 这里 fun1 不是什么函数名，而是一个 指针变量，它指向一个函数。这个函数有两个指针类型的参数，函数的返回值也是一个指针。

B) fun2 是函数名，p1，p2 是参数，其类型为 char*型，函数的返回值为 char * *类型，是个 二级指针。

B) fun3 是函数名，p1，p2 是参数，其类型为 char*型，函数的返回值为 char * 类型。

函数指针的使用：

[cpp] view plain copy

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

函数指针数组：

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

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

函数指针数组的使用：

[cpp] view plain copy

1. <span style="font-size:18px;">#include <stdio.h>  
2. #include <string.h>  
3.   
4. char* fun1(char* p)  
5. {  
6.     printf("%s\n",p);  
7.     return p;  
8. }  
9.   
10. char* fun2(char* p)  
11. {  
12.     printf("%s\n",p);  
13.     return p;  
14. }  
15.   
16. char* fun3(char* p)  
17. {  
18.     printf("%s\n",p);  
19.     return p;  
20. }  
21.   
22. int main()  
23. {  
24.     char* (*pf[3])(char* p);  
25.   
26.     pf[0]= fun1; // 可以直接用函数名  
27.     pf[1]= &fun2; // 可以用函数名加上取地址符  
28.     pf[2]= &fun3;  
29.   
30.     pf[0]("fun1");  
31.     pf[0]("fun2");  
32.     pf[0]("fun3");  
33.   
34.     return 0;  
35. }</span>  

函数指针数组的指针：

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

这里的 pf 和函数指针数组的 pf 就完全是两码事了。函数指针数组的 pf 并非指针，而是一个数组名； 这里的 pf 确实是实实在在的指针。这个指针指向一个包含了 3 个元素的数组；这个数字里 面存的是指向函数的指针；这些指针指向一些返回值类型为指向字符的指针、参数为一个 指向字符的指针的函数。(其实就是函数指针数组的指针里的pf指向的是函数指针数组的pf(次pf非彼pf))。

函数指针数组的指针的使用：

[cpp] view plain copy

1. <span style="font-size:18px;">#include <stdio.h>  
2. #include <string.h>  
3.   
4. char* fun1(char* p)  
5. {  
6.     printf("%s\n",p);  
7.     return p;  
8. }  
9.   
10. char* fun2(char* p)  
11. {  
12.     printf("%s\n",p);  
13.     return p;  
14. }  
15.   
16. char* fun3(char* p)  
17. {  
18.     printf("%s\n",p);  
19.     return p;  
20. }  
21.   
22. int main()  
23. {  
24.     char* (*a[3])(char* p);//这是函数指针数组  
25.     char* (*(*pf)[3])(char* p);//这是函数指针数组的指针  
26.     pf = &a;//pf指向数组a  
27.   
28.     a[0]= fun1;  
29.     a[1]= &fun2;  
30.     a[2]= &fun3;  
31.   
32.     pf[0][0]("fun1");  
33.     pf[0][1]("fun2");  
34.     pf[0][2]("fun3");  
35.   
36.     return 0;  
37. }</span>  

参考书籍：《C 语言深度解剖》陈正冲