【C语言】数组：-- 一维数组 -- 二维数组 -- 数组越界 -- 数组作为函数的参数

超、凢脫俗 2023-09-27 15:16 56阅读 0赞

**目录**

1、数组

1.1 数组的定义

1.2 为什么使用数组

2、一维数组

2.1 一维数组的创建

2.2 一维数组的初始化

2.3 一维数组的使用

2.3.1 数组的下标

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

3、二维数组

3.1 二维数组的创建

3.2 二维数组的初始化

3.3 二维数组的使用

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

4、数组越界

5、数组作为函数参数

--------------------

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*正文开始\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

## 1、数组 ##

### 1.1 数组的定义 ###

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

### 1.2 为什么使用数组 ###

A：*我们创建少量（四五个）的变量时单个创建就可以了，但要是创建大量（十个、二十个、一百个）的相同类型的变量时一个个的定义太过麻烦，这时候我们就可以定义数组来表示。*

## 2、一维数组 ##

### 2.1 一维数组的创建 ###

**数组的创建方式：**

type_t		arr_name		[const_n]
    //type_t 是指数组元素的类型
    //const_n 是一个常量表达式，用来指定数组的大小

实例：

int arr[10];
    char ch[15];
    float arr2[20];
    //以上实例的 [] 里面必须是常量

**注：C99标准前，数组的大小必须是常量表法式。C99标准中，引入了变长数组的概念，变长数组中允许数组的大小用变量来指定。编译器要是不支持就使用不了，vs 编译器就是不支持。**

![4822e7e34f7abc59b926d0dab830860d.png][]

**gcc 是支持 C99 标准的：**

![83ff034829f44d8d738b5c672fdf9d80.png][]

**但是变长数组是不能初始化的。**

### 2.2 一维数组的初始化 ###

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

例如：

*完全初始化：*

int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
    int arr2[3] = { 2,4,5 };
    char arr3[3] = { 'a','b','c' };
    char arr4[5] = "abcde";

*不完全初始化：*

int arr[10] = { 0 };
    int arr2[3] = { 0,1 };
    char arr3[3] = { 'a','b' };
    char arr4[5] = "abc";

**不完全初始化的数组，除了初始化的部分是指定的数字或字符，剩下的部分默认初始化为 0 或者字符 '\\0' 。**

**如果数组初始化了，可以不指定数组的大小，数组大小会根据初始化来确定大小。**

*我们可以通过调试的监视窗口来看看没有初始化的部分：*

![b4c75cf8b29da927891d0113d85c79e2.png][]

![132e029a85b41663860ff73ddb0e2b8a.png][]

**我们再看看没有给定大小的数组在内存中怎样存储:**

#include <stdio.h>
    #include <string.h>
    int main()
    {
    	char arr[] = "abc";
    	int sz = sizeof(arr);
    	int len = strlen(arr);
    	printf("%d %d\n", sz, len);
    
    	char arr1[] = { 'a', 'b', 'c' };
    	int sz1 = sizeof(arr1);
    	int len1 = strlen(arr1);
    	printf("%d %d\n", sz1, len1);
    
        return 0;
    }

*效果展示：*

![a6dbdeac28f76e31759cbb5f815d460a.png][]

我们来想想 **string 的特点与 sizeof 的特点**：

**1.string 是一个库函数，是用来计算字符串长度的。****它只针对字符串的 '\\0' 前的字符。**

**2.sizeof 是单目操作符（运算符），是用来求类型或者变量所占空间大小（单位是字节）。****它是对任何类型都可以进行计算，只管空间大小。**

以此为基础，我们再来对这段代码进行分析：

![215b0d3b44e22f685ae0744c3e71bfb8.png][]

![acf274d7188004395eb1b6c64e5c4696.png][]

**因此打印出来的值就是4 3，3 乱码。**

**我们可以对两个数组进行打印一下再看看效果：**

![b38b0be3cc51c2c5f1e939aedd747cf2.png][]

**字符串的结束标志是 '\\0' ，而arr1并没有 '\\0' ，所以打印出来就是乱码。**

### 2.3 一维数组的使用 ###

对于数组的使用，我们之前介绍了一个**操作符：\[ \]，下标引用操作符。它其实就是数组访问的操作符。**

**我们来看看代码：**

#include <stdio.h>
    int main()
    { 
    	int arr[10] = { 0 };//数组的不完全初始化，这里的[]是语法
    	//计算数组的元素个数
    	int sz = sizeof(arr) / sizeof(arr[0]);
    
    	int i = 0;//做下标
    	for (i = 0; i < 10; i++)
    	{
    		arr[i] = i;//这里的[]才是操作符
    	}
    	//输出数组内容
    	for (i = 0; i < 10; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	return 0;
    }

我们在展示效果之前来想想下面的知识：

#### 2.3.1 数组的下标 ####

*下标是用来访问元素的*

int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
    //下标			0 1 2 3 4 5 6 7 8 9

*数组的大小可以用 sizeof 来求*

int sz = sizeof(arr) / sizeof(arr[0]);
    //				40   /	 4

*基于以上知识，我们对代码进行分析*

![0d76bb675990a470095069ee76847d91.png][]

###    2.4 一维数组在内存中的存储 ###

**我们来看代码**

#include <stdio.h>
    int main()
    { 
    	int arr[10] = { 0 };
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		printf("arr[%d] = %p\n", i, &arr[i]);
    	}
    	return 0;
    }

效果展示：

![2581f624041f0204c3a21d5469a42d0a.png][]

**int 是整形，一个整形是 4 个字节，每次加一都是跳过一个整形（4个字节），所以地址每次都是加 4 。**  
仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的增长：

**一维数组在内存中是连续存放的，地址会随下标的增长而增长。**

![e87ef9e277707f84495605e9689d2f4d.png][]

**我们再看一段代码**

#include <stdio.h>
    int main()
    { 
    	int arr[10] = { 0 };
    	int* p = &arr[0];
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		printf("%p == %p\n", p+i, &arr[i]);
    	}
    	return 0;
    }

*效果展示：*

![5fc9733442c54c4aad52d7aac4e6a70a.png][]

我们可以看到两种取地址的方法取出的地址是一样的，**这是为什么呢？**

A：**p 取出来的地址是数组首元素的地址，p 的类型是 int （整形），+1相当于跳过了四个字节，所以和使用下标访问操作符取出的地址是一致的。**

![4bbb2bd19c2ba6246894b7961bb1cd7d.png][]

**总结：定义的是什么类型的指针，+1就跳过一个什么类型的元素（对应跳过类型一个字节）。**

**如果我们对 p+i 解引用操作就会找出相对应位置的元素**

*效果展示：*

![d12d7f6391f390d516904e66898e6b2d.png][]

## 3、二维数组 ##

### 3.1 二维数组的创建 ###

//二维数组
    int arr[3][4];//三行四列
    char arr[3][5];//三行五列
    double arr[2][4];//两行四列

### 3.2 二维数组的初始化 ###

*二维数组也是的行列也是从 0 开始的，它是一行放满了再放下一行。*

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

**比如这个代码：**

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

*效果展示：*

![2385128f846f966aa2743bd08171c64d.png][]

**注：二维数组的列不能省略，行可以省略**

**二维数组也可以不完全初始化，我们来看看效果：**

![7348d8c35ffaa829a101387a4f3d969a.png][]

**没有初始化的部分也是用 0 来代替。**

二维数组想要找哪个元素也是用下标来找

比如：在一下代码找第二行第一列的数字

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

*效果展示：*

![423288dd66fcf2dccc06288a0c162741.png][]

**要找哪一行那一列的数字就给相对应的横纵坐标各 -1 处理。**

**如果我们想要给每一行放入我们想要放入的数字可以使用下面的方法：**

**比如，第一行放入1 2 3，第二行放入4 5 6，第三行放入7 8 9。**

int arr[3][4] = { {1,2,3},{4,5,6},{7,8,9} };//每一行的数在使用一个{}括起来

*效果展示：*

![de3ddff0e64676f4b9d3f55d5d4a328c.png][]

这样就可以得到我们想要的结果了。

### 3.3 二维数组的使用 ###

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

**看代码：**

#include <stdio.h>
    int main()
    { 
    	int arr[3][4] = { 0 };
    	int i = 0;
    	for (i = 0; i < 3; i++)//行：0 1 2
    	{
    		int j = 0;
    		for (j = 0; j < 4; j++)//列：0 1 2 3
    		{
    			arr[i][j] = i * 4 + j;
    		}
    	}
    	//打印
    	for (i = 0; i < 3; i++)//0 1 2
    	{
    		int j = 0;
    		for (j = 0; j < 4; j++)//0 1 2 3
    		{
    			printf("%2d ", arr[i][j]);
    		}
    		printf("\n");
    	}
    	return 0;
    }

*效果展示：*

![acaa2335eb5191e232ee64d71c813175.png][]

### 3.4 二维数组在内存中的存储 ###

我们还是模仿一维数组，把二维数组的地址打印出来看看

看代码：

#include <stdio.h>
    int main()
    { 
    	int arr[3][3] = { 0 };
    	int i = 0;
    	for (i = 0; i < 3; i++)//行：0 1 2
    	{
    		int j = 0;
    		for (j = 0; j < 4; j++)//列：0 1 2 3
    		{
    			printf("%p\n", &arr[i][j]);
    			printf("\n");
    		}
    	}
    	return 0;
    }

*效果展示：*

![8aad02ce3aa338872e1babfd95738c5e.png][]

**地址仍然是十六进制表示的，并且我们不难发现****二维数组是和一维数组一样是连续的****，也还是相差 4 ，因为是整形。**

**如图：**

![11ffe93ed5cf0f0bd8c563d2c3138c38.png][]

**如果我们访问每一行的各个元素：**

arr[1][j];//第一行
    arr[2][j];//第二行
    arr[3][j];//第三行

**我们可以将它拆解为三行，每一行就可以看作一个一维数组，那么每一行的一维数组也有数组名。arr\[0\]就是第一行的数组名；arr\[1\]就是第二行的数组名；arr\[2\]就是第三行的数组名。多行就以此类推。**

## 4、数组越界 ##

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

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

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

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

二维数组的行、列也有可能存在越界。

## 5、数组作为函数参数 ##

**我们这里以冒泡排序作为例子来讲：**

**冒泡排序默认排位升**

#include <stdio.h>
    void bubble_sort(int arr[])
    {
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	//趟数
    	for (int i = 0; i < sz - 1; i++)
    	{
    		int flag = 1;//假设有序,每一次都置为1
    		//每趟的次数
    		for (int j = 0; j < sz - 1 - i; j++)
    		{
    			if (arr[j] > arr[j + 1])
    			{
    				flag = 0;//flag被执行说明是无序
    				int tmp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = tmp;
    			}
    		}
    		if (1 == flag)//这里的判断就是在验证数组是不是顺序的，是顺序就跳出，提高了代码效率
    			break;
    	}
    }
    int main()
    {
    	int arr[] = { 9,8,7,6,5,4,3,2,1 };
    	bubble_sort(arr);
    	for (int i = 0; i < 9; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	return 0;
    }

*效果展示：*

![929db5921b409a8b6ec28de9f8ac5868.png][]

我们发现这里的就没有实现排序功能呀，这是为什么呢？

我们来调试看看：

![de30ed74d0ce7f0fa1c99d43dbdb49d9.png][]

我们来想一下，传参数组名到底是什么？

![0bf743653f1cd09340f2df584e06d265.png][]

**但是传参后却是 1 。**

**我们深究一下：**

int main()
    {
    	int arr[10] = { 0 };
    	printf("%p\n", arr);
    	printf("%p\n", arr+1);
    	printf("%p\n", &arr[0]);
    	printf("%p\n", &arr[0]+1);
    	printf("%p\n", &arr);
    	printf("%p\n", &arr+1);
    
    	printf("%d\n", sizeof(arr));
    
    	return 0;
    }

*效果展示：*

![1482a5f6b7ab6a325f1e1034a2b64e3c.png][]

我们可以看到，一二行和三四行对应相等，arr 和 &arr是一样，但是+1后完全不一样，一二行相差 4 ，五六行相差 28 不是二十八，而是十六进制中的 二八，由此我们可以看到 &arr 取出来的是整个数组地址；sizeof(arr) 也是计算整个数组。

**总结：**

**数组名是数组首元素的地址。**

**但是有两个例外：**

**1.sizeof（数组名），数组名如果单独放在sizeof内部，这里的数组名表示整个数组，计算的是整个数组的大小。**

**2.&数组名，这里的数组名表示整个数组，取出来的是整个数组的大小。**

**除此之外，遇到的所有的数组名都是数组的首元素地址。**

**我们再回过头看那段代码**

![fef10d58d288d83198e3acafda88c8f4.png][]

![e6a7908c964c8ddb5e1ce549e9af60d2.png][]

我们对那段代码进行更改：

#include <stdio.h>
    void bubble_sort(int* arr, int sz)
    {
    	//趟数
    	for (int i = 0; i < sz - 1; i++)
    	{
    		int flag = 1;//假设有序,每一次都置为1
    		//每趟的次数
    		for (int j = 0; j < sz - 1 - i; j++)
    		{
    			if (arr[j] > arr[j + 1])
    			{
    				flag = 0;//flag被执行说明是无序
    				int tmp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = tmp;
    			}
    		}
    		if (1 == flag)//这里的判断就是在验证数组是不是顺序的，是顺序就跳出，提高了代码效率
    			break;
    	}
    }
    int main()
    {
    	int arr[] = { 9,8,7,6,5,4,3,2,1 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	bubble_sort(arr, sz);
    	for (int i = 0; i < 9; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	return 0;
    }

**我们分析一下 sz**

![dca1afce6ff5fe66a204f35301f3a37f.png][]

![282c9525fc14b375cbe2e9ed59a0669a.png][]

*效果展示：*

![de7fde4996dd5aa85dd5e06d58e382e2.png][]

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*数组篇完结\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

如果有错误请一定要指出来，谢谢大家了!

感觉写的还行留下赞和关注再走也不迟，感谢大家的支持了！！！

[4822e7e34f7abc59b926d0dab830860d.png]: https://img-blog.csdnimg.cn/img_convert/4822e7e34f7abc59b926d0dab830860d.png
[83ff034829f44d8d738b5c672fdf9d80.png]: https://img-blog.csdnimg.cn/img_convert/83ff034829f44d8d738b5c672fdf9d80.png
[b4c75cf8b29da927891d0113d85c79e2.png]: https://img-blog.csdnimg.cn/img_convert/b4c75cf8b29da927891d0113d85c79e2.png
[132e029a85b41663860ff73ddb0e2b8a.png]: https://img-blog.csdnimg.cn/img_convert/132e029a85b41663860ff73ddb0e2b8a.png
[a6dbdeac28f76e31759cbb5f815d460a.png]: https://img-blog.csdnimg.cn/img_convert/a6dbdeac28f76e31759cbb5f815d460a.png
[215b0d3b44e22f685ae0744c3e71bfb8.png]: https://img-blog.csdnimg.cn/img_convert/215b0d3b44e22f685ae0744c3e71bfb8.png
[acf274d7188004395eb1b6c64e5c4696.png]: https://img-blog.csdnimg.cn/img_convert/acf274d7188004395eb1b6c64e5c4696.png
[b38b0be3cc51c2c5f1e939aedd747cf2.png]: https://img-blog.csdnimg.cn/img_convert/b38b0be3cc51c2c5f1e939aedd747cf2.png
[0d76bb675990a470095069ee76847d91.png]: https://img-blog.csdnimg.cn/img_convert/0d76bb675990a470095069ee76847d91.png
[2581f624041f0204c3a21d5469a42d0a.png]: https://img-blog.csdnimg.cn/img_convert/2581f624041f0204c3a21d5469a42d0a.png
[e87ef9e277707f84495605e9689d2f4d.png]: https://img-blog.csdnimg.cn/img_convert/e87ef9e277707f84495605e9689d2f4d.png
[5fc9733442c54c4aad52d7aac4e6a70a.png]: https://img-blog.csdnimg.cn/img_convert/5fc9733442c54c4aad52d7aac4e6a70a.png
[4bbb2bd19c2ba6246894b7961bb1cd7d.png]: https://img-blog.csdnimg.cn/img_convert/4bbb2bd19c2ba6246894b7961bb1cd7d.png
[d12d7f6391f390d516904e66898e6b2d.png]: https://img-blog.csdnimg.cn/img_convert/d12d7f6391f390d516904e66898e6b2d.png
[2385128f846f966aa2743bd08171c64d.png]: https://img-blog.csdnimg.cn/img_convert/2385128f846f966aa2743bd08171c64d.png
[7348d8c35ffaa829a101387a4f3d969a.png]: https://img-blog.csdnimg.cn/img_convert/7348d8c35ffaa829a101387a4f3d969a.png
[423288dd66fcf2dccc06288a0c162741.png]: https://img-blog.csdnimg.cn/img_convert/423288dd66fcf2dccc06288a0c162741.png
[de3ddff0e64676f4b9d3f55d5d4a328c.png]: https://img-blog.csdnimg.cn/img_convert/de3ddff0e64676f4b9d3f55d5d4a328c.png
[acaa2335eb5191e232ee64d71c813175.png]: https://img-blog.csdnimg.cn/img_convert/acaa2335eb5191e232ee64d71c813175.png
[8aad02ce3aa338872e1babfd95738c5e.png]: https://img-blog.csdnimg.cn/img_convert/8aad02ce3aa338872e1babfd95738c5e.png
[11ffe93ed5cf0f0bd8c563d2c3138c38.png]: https://img-blog.csdnimg.cn/img_convert/11ffe93ed5cf0f0bd8c563d2c3138c38.png
[929db5921b409a8b6ec28de9f8ac5868.png]: https://img-blog.csdnimg.cn/img_convert/929db5921b409a8b6ec28de9f8ac5868.png
[de30ed74d0ce7f0fa1c99d43dbdb49d9.png]: https://img-blog.csdnimg.cn/img_convert/de30ed74d0ce7f0fa1c99d43dbdb49d9.png
[0bf743653f1cd09340f2df584e06d265.png]: https://img-blog.csdnimg.cn/img_convert/0bf743653f1cd09340f2df584e06d265.png
[1482a5f6b7ab6a325f1e1034a2b64e3c.png]: https://img-blog.csdnimg.cn/img_convert/1482a5f6b7ab6a325f1e1034a2b64e3c.png
[fef10d58d288d83198e3acafda88c8f4.png]: https://img-blog.csdnimg.cn/img_convert/fef10d58d288d83198e3acafda88c8f4.png
[e6a7908c964c8ddb5e1ce549e9af60d2.png]: https://img-blog.csdnimg.cn/img_convert/e6a7908c964c8ddb5e1ce549e9af60d2.png
[dca1afce6ff5fe66a204f35301f3a37f.png]: https://img-blog.csdnimg.cn/img_convert/dca1afce6ff5fe66a204f35301f3a37f.png
[282c9525fc14b375cbe2e9ed59a0669a.png]: https://img-blog.csdnimg.cn/img_convert/282c9525fc14b375cbe2e9ed59a0669a.png
[de7fde4996dd5aa85dd5e06d58e382e2.png]: https://img-blog.csdnimg.cn/img_convert/de7fde4996dd5aa85dd5e06d58e382e2.png