C语言学习第22篇---数组和指针的关系剖析

知识来源主要是陈正冲老师的《C语言深度解剖》及Delphi Tang老师的《C语言剖析》和《征服C指针》，《C和指针》，有兴趣的朋友可以看我置顶文章获取

数组的本质：

• 数组是一段连续的内存空间
• 数组的空间大小为sizeof（array_type）*array_size
• 数组名可以看做指向数组的第一个元素的常量指针（只是理解，其实是错的，参见《征服C指针》）

实验1：a+1的结果是什么？

      #include <stdio.h>
      int main()
      {
         int a[5] = {0};
         int* p = NULL;
         printf("a = 0x%X\n", (unsigned int)(a));
         printf("a + 1 = 0x%X\n", (unsigned int)(a + 1));
         printf("p = 0x%X\n", (unsigned int)(p));
         printf("p + 1 = 0x%X\n", (unsigned int)(p + 1));
         return 0;
      }
  
 

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

理解：

当指针p指向一个同类型的数组的元素时：p+1将指向当前元素的下一个元素：p-1指向当前元素的上一个元素

指针的运算：

• 指针之间只支持减法运算
• 参与运算的指针类型必须相同

理解：

1. 只有当两个指针指向同一个数组中的元素时，指针相减才有意义，其意义是指针所指元素的下标差
2. 当两个指针指向的元素不在同一个数组中时，结果未定义

指针的比较：

• 指针可以进行关系运算（< , <= , > , >=）
• 指针关系运算的前提是同时指向同一个数组中的元素
• 任意两个指针之间的比较运算（==，！=）无限制
• 参与比较运算的指针类型必须相同

实验2：指针运算

      #include <stdio.h>
      int main()
      {
         char s1[] = {'H', 'e', 'l', 'l', 'o'};
         int i = 0;
         char s2[] = {'W', 'o', 'r', 'l', 'd'};
         char* p0 = s1;
         char* p1 = &s1[3];
         char* p2 = s2;
         int* p = &i;
         printf("%d\n", p0 - p1);
         printf("%d\n", p0 + p2);
         printf("%d\n", p0 - p2);
         printf("%d\n", p0 - p);
         printf("%d\n", p0 * p2);
         printf("%d\n", p0 / p2);
         return 0;
      }
  
 

实验3：指针运算的应用

      #include <stdio.h>
      #define DIM(a) (sizeof(a) / sizeof(*a))
      int main()
      {
         char s[] = {'H', 'e', 'l', 'l', 'o'};
         char* pBegin = s;
         char* pEnd = s + DIM(s); // Key point
         char* p = NULL;
         printf("pBegin = %p\n", pBegin);
         printf("pEnd = %p\n", pEnd);
         printf("Size: %d\n", pEnd - pBegin);
         for(p=pBegin; p<pEnd; p++)
          {
             printf("%c", *p);
          }
         printf("\n");
         return 0;
      }
  
 

数组的访问方式有两种

• 下标的方式
• 指针的形式

分析下两种方式的不同：（下标形式对于阅读代码更优）

• 指针一固定增量在数组中移动时，效率高于下边形式
• 指针增量为1且硬件具有硬件增量模型时，效率更高
• 下标形式与指针形式的转换：

实例4：数组的访问方式

      #include <stdio.h>
      int main()
      {
         int a[5] = {0};
         int* p = a;
         int i = 0;
         for(i=0; i<5; i++)
          {
              p[i] = i + 1;
          }
         for(i=0; i<5; i++)
          {
             printf("a[%d] = %d\n", i, *(a + i));
          }
         printf("\n");
         for(i=0; i<5; i++)
          {
              i[a] = i + 10;
          }
         for(i=0; i<5; i++)
          {
             printf("p[%d] = %d\n", i, p[i]);
          }
         return 0;
      }
  
 

实验5：数组与指针的差别

      #include <stdio.h>
      int main()
      {
         //extern int* a;
     	int a[] = {1, 2, 3, 4, 5};
         printf("&a = %p\n", &a);
         printf("a = %p\n", a);
         printf("*a = %d\n", *a);
         return 0;
      }
      、、、、、、、、、、、、、、、、、
      int a[] = {1, 2, 3, 4, 5};
  
 

a和&a的区别

• a为数组首元素的地址
• &a为整个数组的地址
• a和&a的区别在于指针运算

实例6：指针运算的经典问题

      #include <stdio.h>
      int main()
      {
         int a[5] = {1, 2, 3, 4, 5};
         int* p1 = (int*)(&a + 1);
         int* p2 = (int*)((int)a + 1);
         int* p3 = (int*)(a + 1);
         printf("%d, %d, %d\n", p1[-1], p2[0], p3[1]);
         return 0;
      }
      // A. 数组下标不能是负数，程序无法运行
      // B. p1[-1]将输出随机数，p2[0]输出2， p3[1]输出3
      // C. p1[-1]将输出乱码， p2[0]和p3[1]输出2
  
 

数组函数：数组作为函数参数时，编译器将其编译为对应的指针

实例7：数组参数探究

      #include <stdio.h>
      void func1(char a[5])
      {
         printf("In func1: sizeof(a) = %d\n", sizeof(a));
          *a = 'a';
          a = NULL;
      }
      void func2(char b[])
      {
         printf("In func2: sizeof(b) = %d\n", sizeof(b));
          *b = 'b';
          b = NULL;
      }
      int main()
      {
         char array[10] = {0};
         func1(array);
         printf("array[0] = %c\n", array[0]);
         func2(array);
         printf("array[0] = %c\n", array[0]);
         return 0;
      }
  
 

小结：

文章来源: allen5g.blog.csdn.net，作者：CodeAllen的博客，版权归原作者所有，如需转载，请联系作者。

原文链接：allen5g.blog.csdn.net/article/details/80463348