目录

1. 一维数组

1.1 数组的创建和初始化

数组的创建：

数组的初始化

1.2 一维数组的使用

1.3 一维数组在内存中的存储

1.4 了解数组在存储中的本质

2. 二维数组

2.1 二维数组的创建和初始化

二维数组的创建

二维数组的初始化

2.2 二维数组的使用

2.3 二维数组在内存中的存储

2.4 了解数组在存储中的本质

3. 数组越界

4. 数组作为函数参数

4.1 数组名是什么？

 4.2 冒泡排序函数的设计

5. 数据实例：

5.1 数组的应用实例1：三子棋

5.2 数组的应用实例2：扫雷游戏

1. 一维数组。

1.1 数组的创建和初始化

数组的创建：

数组是创建一组相同类型元素的集合。

数组的创建方式：

</>复制代码 
int   arr   [常量表达式];//int是指数组的元素类型，也可以是float，char这种类型。//在arr[]在[]中放的是常量表达式//在C99之前 —— arr[]中时不能用变量的，要用常量。

数组创建的实例：

</>复制代码 
char arr1[10];float arr2[1];double arr3[20];

数组的初始化

如果只是创建数组（不初始化），然后使用数组，编译器就会报错，因为数组的值是不知道的。

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

</>复制代码 
#includeint main(){
//三种常见的初始化方式
int arr1[20] = { 1,2,3 };//这个数组的空间大小是20*4个字节，前三个元素的值为1，2，3，其他的值默认为0 —— 不完全初始化
int arr2[] = { 1,2,3 };//这个数组的初始化虽然没有给元素个数，但是C语言的语法还是支持的，元素的个数是根据{}中元素个数来给的//{}中有几个元素，这个数组的空间大小就是多少 —— 空间大小为3*4个字节
int arr3[3] = { 1,2,3 };//完全初始化
//理解下面三种数组初始化的含义
char arr4[] = "abc";//这个数组的空间大小为4个字节，其中存放的是a b c /0 —— 字符串后面默认有一个/0。——由“”引起的内容//为字符串
char arr5[] = { "a", "b", "c" };//这个数组的空间大小为3个字节，其中存放的是a b c
char arr6[] = { "a", 98, "c" };//因为数据类型为char类型的，所以98代表的是b，b的ASCII值为98
return 0;}

1.2 一维数组的使用

对于数组的使用我们之前介绍了一个操作符：

[ ] ，下标引用操作符 —— 它其实就数组访问的操作符。

</>复制代码 
#include int main(){    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };   //数组的不完全初始化    int sz = sizeof(arr) / sizeof(arr[0]);   //计算数组的元素个数    //对数组内容赋值,数组是使用下标来访问的，下标从0开始    printf("%d/n", arr[4]);   //打印数字5；    int i = 0;    //利用循环打印数组的内容    for (i = 0; i < sz; i++)    {        printf("%d ", arr[i]);    }    return 0;}

总结:

1. 数组是使用下标来访问的，下标是从0开始。

2. 数组的大小可以通过计算得到。

1.3 一维数组在内存中的存储

代码：

</>复制代码 
#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）数组在内存中是连续存放的  —— （2）数组中的地址是由高到低排序的

1.4 了解数组在存储中的本质

数组在内存中的本质：

（1）数组在内存中是连续存放的 

（2）数组中的地址是由高到低排序的

代码举例：

</>复制代码 
//打印数组中的内容#includeint main(){
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
int* p = arr; //定义指针变量为int类型//普通做法
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("/n");//利用数组在内存中是连续存放的规律
for (i = 0; i < sz; i++)
{
printf("%d ", *p);
p++;  //指针变量+1表示，跳过一个整型空间
}
return 0;}

2. 二维数组

2.1 二维数组的创建和初始化

二维数组的创建

</>复制代码 
int arr[3][4];char arr[3][5];double arr[2][4];

二维数组的初始化

</>复制代码 
//1int arr[3][4] = { 1,2,3,4,5,6,7,8,9,10};

</>复制代码 
//2int arr[3][4] = { {1,2},{4,5} };

</>复制代码 
//3int arr[][4] = { {2,3},{4,5} };//二维数组初始化了，可以省略列数下标，但是不能省略行数下标

</>复制代码 
//4char ch[3][4] = { "abc","bcd" };

2.2 二维数组的使用

二维数组的使用也是通过下标的方式。

</>复制代码 
#include int main(){   int arr[3][4] = {0};   int i = 0;//对arr数组初始化赋值   for(i=0; i<3; i++)   {      int j = 0;      for(j=0; j<4; j++)      {         arr[i][j] = i*4+j;      }   }//打印arr数组的内容   for(i=0; i<3; i++)   {      int j = 0;      for(j=0; j<4; j++)      {         printf("%d ", arr[i][j]);      }   }   return 0;}

2.3 二维数组在内存中的存储

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

</>复制代码 
#include int main(){
int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12,};
int i = 0;//打印数组arr的每一个元素的地址
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 4; j++)
{
printf("&arr[%d][%d] = %p/n", i, j, &arr[i][j]);
}  //%p —— 是打印地址
}
return 0;}

 从上面的结果就可以看出：二维数组在内存中也是连续存储的。

也可以理解成：二维数组有三个元素，每个元素是一个一维数组

 我们可以把二维数组想象成一个几行几列的数组

但是本质上的二维数组是一列的。 ———— 如上图

2.4 了解数组在存储中的本质

数组内存的本质：

（1）数组在内存中是连续存放的 

（2）数组中的地址是由高到低排序的

代码举例：

</>复制代码 
#includeint main(){
int arr[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
int i = 0;
int* p = arr;
//普通的打印方式
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 4; j++)
{
printf("%d ", arr[i][j]);
}
}
printf("/n");
//利用本质来打印数组
for (i = 0; i < 12; i++)
{
printf("%d ", *p);
p++;
}
return 0;}

3. 数组越界

数组的下标是有范围限制的。

数组的下标规定是从0开始的，如果输入有n个元素，最后一个元素的下标就是n-1。

所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。

C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就 是正确的，所以程序员写代码时，最好自己做越界的检查。

代码举例：

</>复制代码 
#includeint main(){
int arr[5] = { 1,2,3,4,5 };
int i = 0;
for (i = 0; i <= 5; i++)  //其中的arr[5]越界访问了
{
printf("%d ", arr[i]);
}
return 0;}

 从上图可知，越界访问的值是系统给的随机值。

 二维数组的行和列也可能存在越界 —— 在这里就不多讲了

4. 数组作为函数参数

4.1 数组名是什么？

</>复制代码 
#include int main(){    int arr[10] = { 1,2,3,4,5 };    printf("%p/n", arr);    printf("%p/n", arr+1);    printf("%p/n", &arr[0]);    printf("%d/n", *arr);    //输出结果    return 0;}

 从上面就可以看出：数组名是首元素的地址

有两种例外的情况：数组名不是首元素的地址。

1. sizeof(数组名)，计算整个数组的大小，sizeof内部多带带放一个数组名，数组名表示整个数组。

2. &数组名，取出的是数组的地址。&数组名，数组名表示整个数组。

除此1,2两种情况之外，所有的数组名都表示数组首元素的地址。

代码演示： 

</>复制代码 
#include int main(){    int arr[10] = { 1,2,3,4,5 };    printf("%p/n", arr);    printf("%p/n", &arr);    printf("----------/n");    printf("%p/n", arr + 1);    printf("%p/n", &arr + 1);    return 0;}

 从结果中我们可以看到：

arr的地址加一 —— 数组的地址跳过 4

&arr的地址加一 —— 数组的地址跳过 40。

有不同的结果是因为：&arr表示的是整个数组的地址，arr表示的是数组第一个元素的地址

 4.2 冒泡排序函数的设计

冒泡排序的原理：

冒泡排序代码： 

</>复制代码 
#includevoid Sort(int arr[], int sz){
int i = 0;
//每趟冒泡排序
for (i = 0; i < sz - 1; i++)
{
int j = 0;
//一趟冒泡排序
for (j = 0; j < sz - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{                //交换
int tem = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tem;
}
}
}}void Print(int arr[], int sz){
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}}int main(){
int arr[10] = { 7,8,9,4,5,6,1,2,3 };
int sz = sizeof(arr) / sizeof(arr[0]);
//冒泡排序
Sort(arr, sz);
//打印数组的内容
Print(arr, sz);
return 0;}

5. 数据实例：

5.1 数组的应用实例1：三子棋

解析 —— 以前我写过的一篇博客连接如下：

三子棋小游戏：   https://blog.csdn.net/IT_Infector/article/details/119216692

5.2 数组的应用实例2：扫雷游戏

解析 —— 以前我写过的一篇博客连接如下：

扫雷小游戏：   https://blog.csdn.net/IT_Infector/article/details/119224857​​​​​​​