指针的本质就是地址

  1. #include <stdio.h>
  3. // 指针
  4. int main()
  5. {
  6.   int i = 5;
  7.   // &是（引用）取地址 指针变量的初始化一定是某个变量取地址
  8.   int *i_pointer = &i;
  9.   // || *是解析地址 如果只是 i_pointer 就是其存的地址
  10.   printf("%d\n", *i_pointer);
  11.   return 0;
  12. }

指针的使用场景通常只有两个，即传递与偏移。

指针传递

  1. #include <stdio.h>
  3. void change(int *j) // j 形参 j=&i
  4. {
  5.   *j = 5;
  6. }
  7. // 指针传递
  8. int main()
  9. {
  10.   int i = 10; //  i 局部变量
  11.   printf("before change , i = %d\n", i);
  12.   change(&i); //函数调用时，把&i称为实参
  13.   printf("after change , i = %d\n", i);
  14.   return 0;
  15. }

指针偏移

前面介绍了指针的传递。指针即地址，就像我们找到了-栋楼，这栋楼的楼号是B,那么往
前就是A，往后就是C,所以应用指针的另一个场景就是对其进行加减，但对指针进行乘除是没
有意义的，就像家庭地址乘以5没有意义那样。在工作中,我们把对指针的加减称为指针的偏移,
加就是向后偏移，减就是向前偏移。

  1. #include <stdio.h>
  3. // 指针偏移
  4. int main()
  5. {
  6.   int a[5] = {1,
  7.               2,
  8.               3,
  9.               4,
  10.               5};
  11.   int *p; //对一个指针变量进行取值，得到的类型是其基类型
  12.   p = a;
  13.   for (int i = 0; i < 5; i++)
  14.   {
  15.     /* 先偏移在取地址 */
  16.     printf("*p = %d \n", *(p + i));
  17.   }
  19.   return 0;
  20. }

指针自增自减

  1. #include <stdio.h>
  3. // p[0] = *p
  5. // 指针自增
  6. int main()
  7. {
  8.   int a[3] = {2, 5, 8};
  9.   int *p;
  10.   int j;
  11.   p = a; // 让指针变量p，指向数组的开头
  12.   // j = *p++;
  13.   j = *p;
  14.   p++;
  15.   printf("a[0] =%d,j =%d,*p =%d\n", a[0], j, *p); // 2,2,5
  16.   // j = p[0]++;
  17.   j = *p;
  18.   printf("之前的*p =%d\n", *p);
  19.   printf("之前的a[1] =%d\n", a[1]);
  21.   // *p++ 指的是这个空间向前加一位 (*p)++ == p[0]++这个地址里面的数加一
  22.   *p++;
  23.   printf("之后的*p =%d\n", *p);
  24.   printf("之后的a[1] =%d\n", a[1]);
  26.   printf("a[1] =%d,j =%d,*p =%d\n", a[1], j, *p); // 6,5,6
  28.   return 0;
  29. }

指针与一维数组

一维 数组在函数调用进行传递时,它的长度子函数无法知道
数组名作为实参传递给子函数时，是弱化为指针的

  1. #include <stdio.h>
  3. void change(char *d)
  4. {
  5.   *d = 'H';
  6.   d[1] = 'E';
  7.   // 等于上面的操作
  8.   // *(d + 1) = 'E';
  9.   *(d + 2) = 'L';
  10. }
  11. // 指针与一维数组
  12. int main()
  13. {
  14.   char c[10] = "hello";
  15.   change(c);
  16.   puts(c);
  17.   return 0;
  18. }

指针与动态内存申请

C语言的数组后会觉得数组长度固定很不方便，其实C语言的数组长度固定是因为其定义的整型、浮点型、字符型变量、数组变量都在栈空间中，而栈空间的大小在编译时是确定的。如果使用的空间大小不确定，那么就要使用堆空间。

程序是放在磁盘上的有序的指令集合