数组名的技术盲点

  • 数组首元素的地址和数组地址是两个不同的概念
  • 数组名代表数组首元素的地址，它是个常量。
    • 解释如下：变量本质是内存空间的别名，一定义数组，就分配内存，内存就固定了。所以数组名起名以后就不能被修改了。
  • 数组首元素的地址和数组的地址值相等
  • 怎么样得到整个一维数组的地址？
  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. #include<string.h>
  5. void main()
  6. {
  7.     int a[] = { 1, 2};
  8.     int b[100] = { 1, 3 };
  10.     int c[200] = { 0 };      //编译时 就已经确定 所有的值 为零
  11.     memset(c, 0, sizeof(c)); //显示的 重置内存块
  12.     // 对一维数组C规定：
  13.     // c  是数组首元素的地址 c+1    步长 4个字节
  14.     // &c 是整个数组的地址   &c+1   步长 200*4
  16.     system("pause");
  17.     return;
  18. }

C语言规定:

  1. Int a[10];
  2. printf("得到整个数组的地址a: %d \n", &a); // 整个数组的地址
  3. printf("数组的首元素的地址a: %d \n", a);  // 首元素的地址

怎么样表达int a[10]这种数据类型那？

数组类型、数组指针类型、数组指针类型变量

数组类型
  • 1数据类型分为基础、非基础，思考角度应该发生变化
  • 2 C语言中的数组有自己特定的类型
    • 数组的类型由元素类型和数组大小共同决定
    • 例：int array[5]的类型为int[5]
数组定义：
  1. typedef int(MYINT5)[5];   //int
  2. typedef float(MYFLOAT10)[10];
  4. MYINT5i Array;   int array[5];
  5. MYFLOAT10fArray
定义数组类型，并用数组类型定义变量
  1. void main()
  2. {
  3.     typedef int(MyArrayType)[5]; // 定义了一个数据类型 数组数据类型
  4.     int i = 0;
  5.     MyArrayType lessons;
  7.     for (i = 0; i < 5; i++) {
  8.         lessons[i] = i + 1;
  9.     }
  11.     printf("lessons:%d lessons+1:%d\n", lessons, lessons + 1);        // lessons  : 4193968   lessons + 1 : 4193972   步长4
  12.     printf("&lessons:%d &lessons+1:%d\n", &lessons, &lessons + 1);  // &lessons : 4193968  &lessons + 1 : 4193988   步长20
  14.     system("pause");
  15.     return;
  16. }

数组指针类型

  • 定义数组指针变量的方法1：用数组类型 加*
  1. void main()
  2. {
  3.     char *MyArray[] = { "111","2222","3333" }; // 指针 数组
  5.     typedef int(MyArrayType)[5]; // 定义了一个数据类型 数组数据类型
  6.     int i = 0;
  7.     MyArrayType lessons;    // 数据类型 定义变量
  9.     MyArrayType *pLessons; // 数据类型 定义一个指针变量 这个指针变量 指向一个数组
  10.     {
  11.         int a;
  12.         int *p = NULL;
  13.         p = &a;
  14.     }
  15.     {
  16.         int lessons2[5];
  17.         // 可以通过指针变量pLessons来操作lessons2的内存空间
  18.         pLessons = &lessons2; // pLessons = &lessons;
  19.         for (i = 0; i < 5; i++) {
  20.             // lessons2[i] = i + 1;
  21.             (*pLessons)[i] = i + 1;
  22.         }
  23.         for (i = 0; i < 5; i++) {
  24.             printf("%d ", (*pLessons)[i]); // 1 2 3 4 5
  25.         }
  26.     }
  28.     system("pause");
  29.     return;
  30. }
  • 定义数组指针变量的方法2
  1. void main()
  2. {
  4.     typedef int (*MyArrayType)[5]; // 定义了一个数组指针类型
  5.     MyArrayType pLessons;          // 告诉编译器 分配一个指针变量
  6.     int c[5];
  7.     int i = 0;
  9.     pLessons = &c;
  11.     for (i = 0; i < 5; i++) {
  12.         (*pLessons)[i] = i + 1;
  13.     }
  14.     for (i = 0; i < 5; i++) {
  15.         printf("%d ", (*pLessons)[i]); // 1 2 3 4 5
  16.     }
  18.     system("pause");
  19.     return;
  20. }
  • 定义数组指针变量的方法3
    • 前面两种方法 通过类型定义 比较麻烦
    • 直接定义 int (*pLessons)[5]
  1. void main()
  2. {
  3.     int c[5];
  4.     int i = 0;
  6.     int (*pLessons)[5]; // 直接定义了一个指向数组的 指针变量
  7.     pLessons = &c;
  9.     for (i = 0; i < 5; i++) {
  10.         (*pLessons)[i] = i + 1;
  11.     }
  12.     for (i = 0; i < 5; i++) {
  13.         printf("%d ", (*pLessons)[i]); // 1 2 3 4 5
  14.     }
  16.     system("pause");
  17.     return;
  18. }

多维数组的本质

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. #include<string.h>
  5. void printfArr1(int a[3][5])
  6. {
  7.     int i, j, tmp = 0;
  8.     for (i = 0; i < 3; i++)
  9.     {
  10.         for (j = 0; j < 5; j++)
  11.         {
  12.             printf("%d ", a[i][j]);
  13.         }
  14.     }
  16.     return;
  17. }
  19. void printfArr2(int a[][5])
  20. {
  21.     int i, j, tmp = 0;
  22.     for (i = 0; i < 3; i++)
  23.     {
  24.         for (j = 0; j < 5; j++)
  25.         {
  26.             printf("%d ", a[i][j]);
  27.         }
  28.     }
  30.     return;
  31. }
  33. //多维数组做函数参数的推演
  34. void printfArr3(int(*b)[5])
  35. {
  36.     int i, j, tmp = 0;
  37.     for (i = 0; i < 3; i++)
  38.     {
  39.         for (j = 0; j < 5; j++)
  40.         {
  41.             printf("%d ", b[i][j]);
  42.         }
  43.     }
  45.     return;
  46. }
  48. void main()
  49. {
  50.     int a[3][5];
  51.     int i = 0, j = 0, tmp = 1;
  53.     for (i = 0; i < 3; i++)
  54.     {
  55.         for (j = 0; j < 5; j++)
  56.         {
  57.             a[i][j] = tmp++;
  58.         }
  59.     }
  60.     printf("\n-------------------\n");
  61.     printfArr3(a);
  62.     printf("\n-------------------\n");
  63.     for (i = 0; i < 3; i++)
  64.     {
  65.         for (j = 0; j < 5; j++)
  66.         {
  67.             printf("%d ,", a[i][j]);
  68.         }
  69.     }
  71.     printf("\na:%d , a+1:%d\n ", a, a + 1);//a+1的步长是20个字节 5*4
  72.     printf("&a:%d , &a+1:%d\n ", &a, &a + 1);
  74.     {
  75.         //定义一个指向数组的指针变量
  76.         int(*pArray)[5];//告诉编译器 分配4个字的内存 32bit平台下
  77.         pArray = a;
  79.         for (i = 0; i < 3; i++)
  80.         {
  81.             for (j = 0; j < 5; j++)
  82.             {
  83.                 printf("%d,", pArray[i][j]);
  84.             }
  85.         }
  86.     }
  87.     /*
  88. 多维数组的本质 数组指针 ，步长 一维的长度
  90. (a)    代表是第0行的整个地址 （第一行的地址 和 第一行首元素的地址是重叠的。。。）
  91. (a+i)  代表是第i行的首地址 2级指针
  92. *(a+i)  代表 1级指针 第i行的首元素的地址
  93. */
  95.     /*
  96. 转化推演：
  98. *( *(a+i) + j) ===>a[i][j]     元素的值
  99. a[i][j] <===> *(*(a+i)+j)
  100. a[i] ===> a[0+i] ===>*(a+i)    0是占位符
  101. a[i][j]===a[0+i][j] ==> *(a+i)[j] ===>*(a+i)[0+j] ===>* ( *(a+i) + j)
  103. **/
  105.     system("pause");
  106.     return;
  107. }