第28课 - 指针和数组分析（上）

1、数组的本质 

            数组是—段连续的内存空间 

            数组的空间大小为sizeof(array_type) * array_size 

            数组名可看做指向数组第—个元素的常量指针 

            问题： 

                    1. a+ 1的意义是什么？结果是什么？ 

                    2. 指针运算的意义是什么？结果又是什么？

2、编程实验

a+1的结果是什么？     28-1.c

1. #include <stdio.h>  
2.   
3. int main()  
4. {  
5.     int a[5] = {0};  
6.     int* p = NULL;  
7.       
8.     printf("a = 0x%X\n", (unsigned int)(a));  
9.     printf("a + 1 = 0x%X\n", (unsigned int)(a + 1));  
10.       
11.     printf("p = 0x%X\n", (unsigned int)(p));  
12.     printf("p + 1 = 0x%X\n", (unsigned int)(p + 1));  
13.       
14.     return 0;  
15. }  

                

3、指针的运算

            指针是一种特殊的变量，与整数的运算规则为 

            p + n;  ↔  (unsigned int)p + n * sizeof(*p); 

            结论：

                    当指针p指向—个同类型的数组的元素时： p+1 

                    将指向当前元素的下—个元素； p -1将指向当前元 

                    素的上—个元素。 

            指针之间只支持减法运算 

            参与减法运算的指针类型必须相同 

            p1 - p2;   ↔ ((unsigned int)p1 - (unsigned int)p2) / sizeof(type); 

            注意： 

                    1. 只有当两个指针指向同—个数组中的元素时，指针相减才减

                        有意义，其意义为指针所指元素的下标差 

                    2. 当两个指针指向的元素不在同一个数组中时，结果未定义 

4、指针的比较

            指针也可以进行关系运算（＜， <=, >, >=) 

            指针关系运算的前提是同时指向同—个数组中的元素 

            任意两个指针之间的比较运算(==,!=)无限制 

            参与比较运算的指针类型必须相同 

5、实例分析

指针运算初探     28-2.c

1. #include <stdio.h>  
2.   
3. int main()  
4. {  
5.     char s1[] = {'H', 'e', 'l', 'l', 'o'};  
6.     int i = 0;  
7.     char s2[] = {'W', 'o', 'r', 'l', 'd'};  
8.     char* p0 = s1;  //指向数组第一个元素
9.     char* p1 = &s1[3];  
10.     char* p2 = s2;  
11.     int* p = &i;  
12.       
13.     printf("%d\n", p0 - p1);  
14.  //   printf("%d\n", p0 + p2);      //error
15.     printf("%d\n", p0 - p2);     //虽然编译通过，但结果不可预期
16.   //  printf("%d\n", p0 - p);      //error
17.  //   printf("%d\n", p0 * p2);      //error
18.  //   printf("%d\n", p0 / p2);      //error
19.       
20.     return 0;  
21. }  

                        

6、实例分析

指针运算的应用     28-3.c

1. #include <stdio.h>  
2.   
3. #define DIM(a) (sizeof(a) / sizeof(*a))  
4.   
5. int main()  
6. {  
7.     char s[] = {'H', 'e', 'l', 'l', 'o'};  
8.     char* pBegin = s;  
9.     char* pEnd = s + DIM(s); // Key point  
10.     char* p = NULL;  
11.       
12.     printf("pBegin = %p\n", pBegin);  
13.     printf("pEnd = %p\n", pEnd);  
14.       
15.     printf("Size: %d\n", pEnd - pBegin);  
16.       
17.     for(p=pBegin; p<pEnd; p++)  
18.     {  
19.         printf("%c", *p);  
20.     }  
21.       
22.     printf("\n");  
23.      
24.     return 0;  
25. }  

                        

                                     0xbf9e07b7 + 1*5 = 0xbf9e07bc

7、小结

            数组声明时编译器自动分配—片连续的内存空间 

            指针声明时只分配了用于容纳地址值的4字节空间 

            指针和整数可以进行运算，其结果为指针 

            指针之间只支持减法运算，其结果为数组元素下标差 

            指针之间支持比较运算，其类型必须相同