1. 一维数组

  1. 元素类型角度：数组是相同类型的变量的有序集合
  2. 内存角度：连续的一大片内存空间

image.png

1.1 数组名

  1. int a;
  2. int b[10];

我们把a称作标量，因为它是个单一的值，这个变量是的类型是一个整数。我们把b称作数组，因为它是一些值的集合。下标和数名一起使用，用于标识该集合中某个特定的值。例如，b[0]表示数组b的第1个值，b[4]表示第5个值。每个值都是一个特定的标量。
那么问题是b的类型是什么？它所表示的又是什么？一个合乎逻辑的答案是它表示整个数组，但事实并非如此。在C中，在几乎所有数组名的表达式中，数组名的值是一个指针常量，也就是数组第一个元素的地址。它的类型取决于数组元素的类型：如果他们是int类型，那么数组名的类型就是“指向int的常量指针”；如果它们是其他类型，那么数组名的类型也就是“指向其他类型的常量指针”。

指针和数组是等价的吗？
答案是否定的。数组名在表达式中使用的时候，编译器才会产生一个指针常量。那么数组在什么情况下不能作为指针常量呢？在以下两种场景下：

  1. 当数组名作为sizeof操作符的操作数的时候，此时sizeof返回的是整个数组的长度，而不是指针数组指针的长度。
  2. 当数组名作为&操作符的操作数的时候，此时返回的是一个指向数组的指针，而不是指向某个数组元素的指针常量。
    1. int arr[10];
    2. //arr = NULL; //arr作为指针常量，不可修改
    3. int *p = arr; //此时arr作为指针常量来使用
    4. printf("sizeof(arr):%d\n", sizeof(arr)); //此时sizeof结果为整个数组的长度
    5. printf("&arr type is %s\n", typeid(&arr).name()); //int(*)[10]而不是int*

1.2 下标引用

  1. int arr[] = { 1, 2, 3, 4, 5, 6 };

*(arr + 3) ,这个表达式是什么意思呢？
首先，我们说数组在表达式中是一个指向整型的指针，所以此表达式表示arr指针向后移动了3个元素的长度。然后通过间接访问操作符从这个新地址开始获取这个位置的值。这个和下标的引用的执行过程完全相同。所以如下表达式是等同的：

  1. *(arr + 3)
  2. arr[3]

问题1：数组下标可否为负值？
可以，前后越界c语言不检查
问题2：请阅读如下代码，说出结果：

  1. int arr[] = { 5, 3, 6, 8, 2, 9 };
  2. int *p = arr + 2;
  3. printf("*p = %d\n", *p); // 6
  4. printf("*p = %d\n", p[-1]);  // 3

1.3 数组和指针

指针和数组并不是相等的。为了说明这个概念，请考虑下面两个声明：

  1. int a[10];
  2. int *b;

声明一个数组时，编译器根据声明所指定的元素数量为数组分配内存空间，然后再创建数组名，指向这段空间的起始位置。声明一个指针变量的时候，编译器只为指针本身分配内存空间，并不为任何整型值分配内存空间，指针并未初始化指向任何现有的内存空间。
因此，表达式a是完全合法的，但是表达式b却是非法的。*b将访问内存中一个不确定的位置，将会导致程序终止。另一方面b++可以通过编译，a++却不行，因为a是一个常量值。

1.4 作为函数参数的数组名

当一个数组名作为一个参数传递给一个函数的时候发生什么情况呢？我们现在知道数组名其实就是一个指向数组第1个元素的指针，所以很明白此时传递给函数的是一份指针的拷贝。所以函数的形参实际上是一个指针。但是为了使程序员新手容易上手一些，编译器也接受数组形式的函数形参。因此下面两种函数原型是相等的：

  1. int print_array(int *arr);
  2. int print_array(int arr[]);

我们可以使用任何一种声明，但哪一个更准确一些呢？答案是指针。因为实参实际上是个指针，而不是数组。同样sizeof arr值是指针的长度，而不是数组的长度。
现在我们清楚了，为什么一维数组中无须写明它的元素数目了，因为形参只是一个指针，并不需要为数组参数分配内存。另一方面，这种方式使得函数无法知道数组的长度。如果函数需要知道数组的长度，它必须显式传递一个长度参数给函数。

2. 多维数组

如果某个数组的维数不止1个，它就被称为多维数组。接下来的案例讲解以二维数组举例。

  1. void test01(){
  2.     //二维数组初始化
  3.     int arr1[3][3] = {
  4.         { 1, 2, 3 },
  5.         { 4, 5, 6 },
  6.         { 7, 8, 9 }
  7.     };
  8.     int arr2[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  9.     int arr3[][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  11.     //打印二维数组
  12.     for (int i = 0; i < 3; i++){
  13.         for (int j = 0; j < 3; j ++){
  14.             printf("%d ",arr1[i][j]);
  15.         }
  16.         printf("\n");
  17.     }
  18. }

2.1 数组名

一维数组名的值是一个指针常量，它的类型是“指向元素类型的指针”，它指向数组的第1个元素。多维数组也是同理，多维数组的数组名也是指向第一个元素，只不过第一个元素是一个数组。例如：

  1. int arr[3][10]

可以理解为这是一个一维数组，包含了3个元素，只是每个元素恰好是包含了10个元素的数组。arr就表示指向它的第1个元素的指针，所以arr是一个指向了包含了10个整型元素的数组的指针。

2.2 指向数组的指针(数组指针)

数组指针，它是指针，指向数组的指针。
数组的类型由元素类型和数组大小共同决定：int array[5] 的类型为 int[5]；C语言可通过typedef定义一个数组类型：
定义数组指针有一下三种方式：

  1. //方式一
  2. void test01(){
  4.     //先定义数组类型，再用数组类型定义数组指针
  5.     int arr[10] = {1,2,3,4,5,6,7,8,9,10};
  6.     //有typedef是定义类型，没有则是定义变量,下面代码定义了一个数组类型ArrayType
  7.     typedef int(ArrayType)[10];
  8.     //int ArrayType[10]; //定义一个数组，数组名为ArrayType
  10.     ArrayType myarr; //等价于 int myarr[10];
  11.     ArrayType* pArr = &arr; //定义了一个数组指针pArr，并且指针指向数组arr
  12.     for (int i = 0; i < 10;i++){
  13.         printf("%d ",(*pArr)[i]);
  14.     }
  15.     printf("\n");
  16. }
  18. //方式二
  19. void test02(){
  21.     int arr[10];
  22.     //定义数组指针类型
  23.     typedef int(*ArrayType)[10];
  24.     ArrayType pArr = &arr; //定义了一个数组指针pArr，并且指针指向数组arr
  25.     for (int i = 0; i < 10; i++){
  26.         (*pArr)[i] = i + 1;
  27.     }
  28.     for (int i = 0; i < 10; i++){
  29.         printf("%d ", (*pArr)[i]);
  30.     }
  31.     printf("\n");
  33. }
  35. //方式三
  36. void test03(){
  38.     int arr[10];
  39.     int(*pArr)[10] = &arr;
  41.     for (int i = 0; i < 10; i++){
  42.         (*pArr)[i] = i + 1;
  44.     }
  45.     for (int i = 0; i < 10; i++){
  46.         printf("%d ", (*pArr)[i]);
  47.     }
  48.     printf("\n");
  49. }

2.3 指针数组(元素为指针)

2.3.1 栈区指针数组

  1. //数组做函数函数，退化为指针
  2. void array_sort(char** arr,int len){
  4.     for (int i = 0; i < len; i++){
  5.         for (int j = len - 1; j > i; j --){
  6.             //比较两个字符串
  7.             if (strcmp(arr[j-1],arr[j]) > 0){
  8.                 char* temp = arr[j - 1];
  9.                 arr[j - 1] = arr[j];
  10.                 arr[j] = temp;
  11.             }
  12.         }
  13.     }
  15. }
  17. //打印数组
  18. void array_print(char** arr,int len){
  19.     for (int i = 0; i < len;i++){
  20.         printf("%s\n",arr[i]);
  21.     }
  22.     printf("----------------------\n");
  23. }
  25. void test(){
  27.     //主调函数分配内存
  28.     //指针数组
  29.     char* p[] = { "bbb", "aaa", "ccc", "eee", "ddd"};
  30.     //char** p = { "aaa", "bbb", "ccc", "ddd", "eee" }; //错误
  31.     int len = sizeof(p) / sizeof(char*);
  32.     //打印数组
  33.     array_print(p, len);
  34.     //对字符串进行排序
  35.     array_sort(p, len);
  36.     //打印数组
  37.     array_print(p, len);
  38. }

2.3.2 堆区指针数组

  1. //分配内存
  2. char** allocate_memory(int n){
  4.     if (n < 0 ){
  5.         return NULL;
  6.     }
  8.     char** temp = (char**)malloc(sizeof(char*) * n);
  9.     if (temp == NULL){
  10.         return NULL;
  11.     }
  13.     //分别给每一个指针malloc分配内存
  14.     for (int i = 0; i < n; i ++){
  15.         temp[i] = malloc(sizeof(char)* 30);
  16.         sprintf(temp[i], "%2d_hello world!", i + 1);
  17.     }
  19.     return temp;
  20. }
  22. //打印数组
  23. void array_print(char** arr,int len){
  24.     for (int i = 0; i < len;i++){
  25.         printf("%s\n",arr[i]);
  26.     }
  27.     printf("----------------------\n");
  28. }
  30. //释放内存
  31. void free_memory(char** buf,int len){
  32.     if (buf == NULL){
  33.         return;
  34.     }
  35.     for (int i = 0; i < len; i ++){
  36.         free(buf[i]);
  37.         buf[i] = NULL;
  38.     }
  40.     free(buf);
  41. }
  43. void test(){
  45.     int n = 10;
  46.     char** p = allocate_memory(n);
  47.     //打印数组
  48.     array_print(p, n);
  49.     //释放内存
  50.     free_memory(p, n);
  51. }

2.4 二维数组三种参数形式

2.4.1 二维数组的线性存储特性

  1. void PrintArray(int* arr, int len){
  2.     for (int i = 0; i < len; i++){
  3.         printf("%d ", arr[i]);
  4.     }
  5.     printf("\n");
  6. }
  8. //二维数组的线性存储
  9. void test(){
  10.     int arr[][3] = {
  11.         { 1, 2, 3 },
  12.         { 4, 5, 6 },
  13.         { 7, 8, 9 }
  14.     };
  16.     int arr2[][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  17.     int len = sizeof(arr2) / sizeof(int);
  19.     //如何证明二维数组是线性的？
  20.     //通过将数组首地址指针转成Int*类型，那么步长就变成了4，就可以遍历整个数组
  21.     int* p = (int*)arr;
  22.     for (int i = 0; i < len; i++){
  23.         printf("%d ", p[i]);
  24.     }
  25.     printf("\n");
  27.     PrintArray((int*)arr, len);
  28.     PrintArray((int*)arr2, len);
  29. }

2.4.2 二维数组的3种形式参数

  1. //二维数组的第一种形式
  2. void PrintArray01(int arr[3][3]){
  3.     for (int i = 0; i < 3; i++){
  4.         for (int j = 0; j < 3; j++){
  5.             printf("arr[%d][%d]:%d\n", i, j, arr[i][j]);
  6.         }
  7.     }
  8. }
  10. //二维数组的第二种形式
  11. void PrintArray02(int arr[][3]){
  12.     for (int i = 0; i < 3; i++){
  13.         for (int j = 0; j < 3; j++){
  14.             printf("arr[%d][%d]:%d\n", i, j, arr[i][j]);
  15.         }
  16.     }
  17. }
  19. //二维数组的第二种形式
  20. void PrintArray03(int(*arr)[3]){
  21.     for (int i = 0; i < 3; i++){
  22.         for (int j = 0; j < 3; j++){
  23.             printf("arr[%d][%d]:%d\n", i, j, arr[i][j]);
  24.         }
  25.     }
  26. }
  28. void test(){
  30.     int arr[][3] = { 
  31.         { 1, 2, 3 },
  32.         { 4, 5, 6 },
  33.         { 7, 8, 9 }
  34.     };
  36.     PrintArray01(arr);
  37.     PrintArray02(arr);
  38.     PrintArray03(arr);
  39. }

3 总结

3.1 编程提示

  1. 源代码的可读性几乎总是比程序的运行时效率更为重要
  2. 只要有可能，函数的指针形参都应该声明为const
  3. 在多维数组的初始值列表中使用完整的多层花括号提高可读性

3.2 内容总结

在绝大多数表达式中，数组名的值是指向数组第1个元素的指针。这个规则只有两个例外，sizeof和对数组名&。
指针和数组并不相等。当我们声明一个数组的时候，同时也分配了内存。但是声明指针的时候，只分配容纳指针本身的空间。
当数组名作为函数参数时，实际传递给函数的是一个指向数组第1个元素的指针。
我们不单可以创建指向普通变量的指针，也可创建指向数组的指针。