1. 一维数组的创建和初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。

  1. /*
  2. strlen:只与字符串有关系，用来求字符串的长度，是一个库函数，需要引入头文件
  3. sizeof：计算变量、数组、类型的大小，单位是字节，是一个操作符
  4. */
  5. char arr4[] = "abcefg";
  6. //strlen:计算字符串的长度
  7. printf("strlen:%d\n", strlen(arr4));//6
  8. //sizeof:计算字符串所占用的空间
  9. printf("sizeof:%d\n", sizeof(arr4));//7

2. 一维数组的使用

  1. 数组是使用下标来访问的，下标是从0开始。
    2. 数组的大小可以通过计算得到。
    1. //两种遍历数组的方式
    2. #include<stdio.h>
    3. #include<string.h>
    4. int main() {
    5.  /*char arr1[] = "abcdef";
    6.  for (int i = 0; i < strlen(arr1); i++) {
    7.      printf("%c",arr1[i]);
    8.  }
    9.  return 0;*/
    10.  char arr2[] = { 'a','b','c','d','e','f' };
    11.  int len = sizeof(arr2) / sizeof(arr2[0]);
    12.  for (int i = 0; i < len; i++) {
    13.      printf("%c", arr2[i]);
    14.  }
    15. }

    3. 一维数组在内存中的存储

    ```c

    include

    int main(){ int arr[10] = {0}; int i = 0; int sz = sizeof(arr)/sizeof(arr[0]); for(i=0; i<sz; ++i){ printf(“&arr[%d] = %p\n”, i, &arr[i]); } return 0; } /* 仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。 由此可以得出结论：数组在内存中是连续存放的。

*/

  1. ![C-01.png](https://cdn.nlark.com/yuque/0/2022/png/12806635/1656160351283-00ab281c-7adb-4777-ad61-6da7faeedd55.png#clientId=u3c625b46-35cb-4&crop=0&crop=0&crop=1&crop=1&from=ui&id=uf2459401&margin=%5Bobject%20Object%5D&name=C-01.png&originHeight=245&originWidth=230&originalType=binary&ratio=1&rotation=0&showTitle=false&size=8300&status=done&style=none&taskId=udd9c8c66-fd88-4b42-ac2b-fcbcfbf76cb&title=)
  3. <a name="v0KgX"></a>
  4. ### 4. 二维数组的创建和初始化 
  5. ```c
  6. //数组创建
  7. int arr[3][4];
  8. char arr[3][5];
  9. double arr[2][4];
  10. //数组初始化
  11. int arr[3][4] = {1,2,3,4};
  12. int arr[3][4] = {{1,2},{4,5}};
  13. int arr[][4] = {{2,3},{4,5}};//二维数组如果有初始化，行可以省略，列不能省略

5. 二维数组的使用

  1. #include <stdio.h>
  2. int main(){
  3.  int arr[3][4] = {0};
  4.  int i = 0;
  5.  for(i=0; i<3; i++){
  6.      int j = 0;
  7.      for(j=0; j<4; j++){
  8.          arr[i][j] = i*4+j;
  9.          }
  10.  }
  13.  for(i=0; i<3; i++){
  14.      int j = 0;
  15.      for(j=0; j<4; j++){
  16.          printf("%d ", arr[i][j]);
  17.      }
  18.  }
  19.  return 0;
  20. }

6. 二维数组在内存中的存储

像一维数组一样，这里我们尝试打印二维数组的每个元素。

  1. #include <stdio.h>
  2. int main(){
  3.  int arr[3][4];
  4.  int i = 0;
  5.  for(i=0; i<3; i++){
  6.      int j = 0;
  7.      for(j=0; j<4; j++){
  8.          printf("&arr[%d][%d] = %p\n", i, j,&arr[i][j]);
  9.      }
  10.  }
  11.  return 0;
  12. }
  13. /*
  14. 通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。
  17. */

C-02.png

7. 数组越界

数组的下标是有范围限制的。 数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。 所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。 C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就 是正确的， 所以程序员写代码时，最好自己做越界的检查,二维数组的行和列也可能存在越界。

8. 数组作为函数参数