玩转C语言——数组初探

一、前言

       通过前面的学习，我们已了解C语言的结构变量、分支结构和循环结构。今天，我们一起来认识C语言的另一知识点——数组。先赞后看，养成习惯。

二、数组概念

       学习数组，我们要明白数组是什么。在我看来：数组是⼀组相同类型元素的集合。

       从这句话中，我们可以提取到如下的信息：

•        数组可以存放相同的数据且类型相同。
•        数组的元素个数不为零。

       数组分为⼀维数组和多维数组，多维数组⼀般⽐较多⻅的是⼆维数组。

三、一维数组

       3.1 一维数组的创建

•        存放在数组的值被称为数组的元素，数组在创建的时候可以指定数组的⼤⼩和数组的元素类型。
•        类型说明符就是我们常用的存储类型（如：int 、short、char......）当然也可以自定义类型。
•        数组名就是自取的名字，要取得方便阅读。
•        []是用来确定数组大小的，可根据需要而定。

               基本创建语法如下：

1. 
2.  int arr1[0];//0表示元素个数
3.  short arr2[0];
4.  char arr3[0];
5.  float arr4[0];
6.  double arr5[0+1];//表达式形式也可以
7. 
8.

        3.2 一维数组的初始化

       在创建数组的时候，我们需要对数组进行初始化，那我们该如何进行初始化呢？且听我细细道来：

       在进行初始化时，我们一般使用大括号的形式，即把数据放入大括号中。

       初始化有分为：完全初始化和不完全初始化。

       那什么是完全初始化什么又是不完全初始化呢？可这样理解：假如你家有五口人，每个人都能分到一包饼干，这就是完全初始化；反之，则是不完全初始化。在我们写代码过程中，大多数都是用不完全初始化。

       代码如下：

1. 
2. 
3.  int arr1[0] = { 0 };//完全初始化
4.  int arr2[2] = { 0 };//不完全初始化
5.  int arr3[3] = { 0，0 ];//不完全初始化
6.  int arr4[5];//错误初始化，在VS中会报错
7. 
8. 
9. 
10. 
11.

       3.3一维数组的类型

       数组的类型就是去除数组名就是其类型，以上述代码为例：

1. 
2. 
3. 
4.  int arr1[0] = { 0 };//数组类型为int [0]
5.  int arr2[2] = { 0 };//数组类型为int [2]
6.  char arr3[3] = { 0，0 ];//数组类型为 char [3]
7. 
8. 
9. 
10. 
11. 
12. 
13.

       3.4 一维数组的使用

       在学习完基本的语法后，我们就要学习对其使用了，一维数组可以存放数据，存放数据的⽬的是对数据的操作，那我们该如何使用呢？

       3.4.1 数组下标

               C语⾔规定数组是有下标的，下标是从0开始的，假设数组有n个元素，最后⼀个元素的下标是n-1，下 标就相当于数组元素的编号，如下：

        在C语⾔中数组的访问提供了⼀个操作符 [] ，这个操作符叫：下标引⽤操作符。 有了下标访问操作符，我们就可以轻松的访问到数组的元素了.

       3.4.2 数组的打印

               大家是不是现在很好奇一维数组是怎么打印的。在这里提供两种方法：

       法一：

1. #include <stdio.h>
2. int main()
3. {
4.  char arr[] = "123456";
5.  printf("%s", arr);
6.  return 0;
7. }

       %s可以打印字符串，因此可以采用此方法。

       法二：

1. #include <stdio.h>
2. int main()
3. {
4.  char arr[6] = { 1,2,3,4,5,6 };
5.  int i = 0;
6.  for (i = 0; i < 6; i++)
7.  {
8.    printf("%d", arr[i]);
9.  }
10.   return 0;
11. }

       此方法用之前学习过的for循环，运用循环的方式，逐个打印。

       3.4.3 数组的输入

       明白了打印，自然就明白了输入，这里仍提供两种方法。

       法一：

1. #include <stdio.h>
2. int main()
3. {
4.  int arr[2] = { 1,2 };
5.  int i = 0;
6.  for (i = 0; i < 2; i++)
7.  {
8.    scanf("%d", &arr[i]);
9.  }
10.   for (i = 0; i < 2; i++)
11.   {
12.     printf("%d", arr[i]);
13.   }
14.   return 0;
15. }

       整体思路和上述法二一样，运用for循环进行输入及打印。

       法二：

       可借助gets（）进行输入。代码如下：

1. #include <stdio.h>
2. int main()
3. {
4.  char arr[2] = { 0 };
5.  int i = 0;
6.  gets(arr);
7.  printf("%s", arr);
8.  return 0;
9. }

       3.4.4 数组的存储

       有了前⾯的知识，我们其实使⽤数组基本没有什么障碍了，如果我们要深⼊了解数组，我们最好能了 解⼀下数组在内存中的存储。

1. #include <stdio.h>
2. int main()
3. {
4.  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
5.  int i = 0;
6.  for (i = 0; i < 10; i++)
7.  {
8.    printf("&arr[%d] = %p\n ", i, &arr[i]);
9.  }
10.   return 0;
11. }

结果如下：

       从输出的结果我们分析，数组随着下标的增⻓，地址是由⼩到⼤变化的，并且我们发现每两个相邻的 元素之间相差4（因为⼀个整型是4个字节）。所以我们得出结论：数组在内存中是连续存放的。

四、二维数组

       前⾯学习的数组被称为⼀维数组，数组的元素都是内置类型的，如果我们把⼀维数组做为数组的元 素，这时候就是⼆维数组，⼆维数组作为数组元素的数组被称为三维数组，⼆维数组以上的数组统称 为多维数组。

        4.1二维数组的创建及初始化

       我们已学习了一维数组的创建及初始化，那⼆维数组如何初始化呢？像⼀维数组⼀样，也是使⽤⼤括号初始化的。

       类比一维数组的定义，只不过二维数组第一个常量表达式表示行，第二个常量表达式表示列。

1. int arr[5][5];//创建五行五列的二维数组
2. char arr2[3][5];//字符型二维数组
3. float arr3[4][5];//浮点型二维数组

       其初始化与一维数组大致一样，都分为完全初始化和不完全初始化。

1. int arr1[3][5] = {1,2};//不完全初始化
2. int arr2[3][5] = {0};//不完全初始化
3. int arr3[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};//完全初始化
4. int arr4[3][5] = {{1,2},{3,4},{5,6}};//按照⾏初始化
5. int arr5[][5] = {1,2,3};//初始化时省略⾏，但是不能省略列

       4.2 ⼆维数组的使⽤

               4.2.1 ⼆维数组的下标

        当我们掌握了⼆维数组的创建和初始化，那我们怎么使⽤⼆维数组呢？ 其实⼆维数组访问也是使⽤下标的形式的，⼆维数组是有⾏和列的，只要锁定了⾏和列就能唯⼀锁定 数组中的⼀个元素。 C语⾔规定，⼆维数组的⾏是从0开始的，列也是从0开始的，如下所⽰：

int arr[3][5] = {1,2,3,4,5, 6,7,8,9,10, 11,12,13,14,15};

               4.2.2 二维数组的输入和输出

       访问⼆维数组的单个元素我们知道了，那如何访问整个⼆维数组呢？ 其实我们只要能够按照⼀定的规律产⽣所有的⾏和列的数字就⾏；以上⼀段代码中的arr数组为例，⾏ 的选择范围是0~2，列的取值范围是0~4，所以我们可以借助循环实现⽣成所有的下标。

1. int main()
2. {
3.  int arr[3][5] = { 1,2,3,4,5, 6,7,8,9,10, 11,12,13,14,15 };
4.  int i = 0;
5.  for(i = 0; i < 3; i++)
6.  {
7.    int j = 0;
8.    for (j = 0; j < 5; j++)
9.    {
10.       printf("%d", arr[i][j]);
11.     }
12.     printf("\n");
13.   }
14.   return 0;
15. }

       结果如下：

       4.2.3 ⼆维数组在内存中的存储

       像⼀维数组⼀样，我们如果想研究⼆维数组在内存中的存储⽅式，我们也是可以打印出数组所有元素 的地址的。代码如下：

1. #include<stdio.h>
2. int main()
3. {
4.  int arr[3][5] = { 1,2,3,4,5, 6,7,8,9,10, 11,12,13,14,15 };
5.  int i = 0;
6.  for(i = 0; i < 3; i++)
7.  {
8.    int j = 0;
9.    for (j = 0; j < 5; j++)
10.     {
11.       printf("%p\n", &arr[i][j]);
12.     }
13.     printf("\n");
14.   }
15.   return 0;
16. }

       结果如下：

       从输出的结果来看，每⼀⾏内部的每个元素都是相邻的，地址之间相差4个字节，跨⾏位置处的两个元 素（如：arr[0][4]和arr[1][0]）之间也是差4个字节，所以⼆维数组中的每个元素都是连续存放的。

五、数组练习

       多个字符从两端移动，向中间汇聚 编写代码，演⽰多个字符从两端移动，向中间汇聚

       分析：

       若要完成此题，需要借个操作符：strlen和函数：Sleep。

       一下是解释：

C语言中的 sleep 函数可以让当前线程暂停执行一段时间，通常用于模拟实际运行环境下的等待或延时操作。在 Windows 和 Linux 等主流操作系统中，sleep 函数的实现方式略有不同，但其基本原理都是通过让线程进入睡眠状态来实现等待或延时的效果。

其中，seconds 参数表示线程需要暂停的秒数。sleep 函数返回值为 0，表示线程成功地暂停了指定的秒数，如果 sleep 函数被其他信号打断，则返回值为剩余需要暂停的秒数。

需要注意的是，sleep 函数的参数类型为 unsigned int，而不是浮点数类型。如果需要暂停小于 1 秒的时间，可以使用 usleep 函数，它的参数类型为微秒（unsigned int），可以精确地控制线程的等待时间。

       在每次输出之后，使用 sleep 函数暂停 1 秒，模拟实际运行环境下的延时操作。需要注意的是，在使用 sleep 函数时，应该将输出立即刷新到控制台上，否则可能会出现输出延迟的情况。

另外，需要注意的是，sleep 函数会让当前线程进入睡眠状态，因此在调用 sleep 函数时，应该确保当前线程已经完成了所有需要执行的操作，否则可能会导致程序出现不可预测的结果。同时，需要注意不要在循环中频繁地调用 sleep 函数，否则可能会降低程序的性能，影响程序的正常运行。

需要注意的是，在不同的操作系统中，sleep 函数的精度和可靠性可能会有所不同。在一些嵌入式系统中，sleep 函数的精度可能会受到系统时钟精度的限制，导致实际暂停的时间可能会比预期的时间短。因此，在使用 sleep 函数时，应该根据实际需要选择合适的等待时间，并且在代码中添加必要的异常处理机制，以确保程序的稳定性和可靠性。

       总的来说：strlen是计算长度的，sleep是延迟打印。

       可参考如下代码：

1. #define _CRT_SECURE_NO_WARNINGS 1
2. #include <stdio.h>
3. int main()
4. {
5.  char arr1[] = "hello,world" ;
6.  char arr2[] = "###########" ;
7.  int left = 0;
8.  int right = strlen(arr2) - 1;
9.  while (left <= right)
10.   {
11.     Sleep(1000);
12.     arr2[right] = arr1[right];
13.     arr2[left] = arr1[left];
14.     left++;
15.     right--;
16.     printf("%s\n", arr2);
17.   }
18.   return 0;
19. }

       结果如下：

        六、最后

       今天的学习到这里就结束了，如果有什么问题可以留言，我会尽我所能为你解答。

完！