【C语言入门必看】数组

大猩猩！

已于 2022-03-19 22:10:36 修改

阅读量1k

点赞数 15

分类专栏： C语言基础文章标签： c语言开发语言后端

于 2021-11-03 22:25:34 首次发布

本文链接：https://blog.csdn.net/weixin_50614301/article/details/119985779

版权

C语言基础专栏收录该内容

8 篇文章 11 订阅

订阅专栏

本章前言
在这里插入图片描述

一、一维数组的创建和初始化

1.一维数组的创建

1.1数组的创建

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

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

举些例子：

	int arr1[10];
	char arr2[5];
	float arr3[3];
	//正确创建

注意：创建数组时，[ ]里放的是常量，而不是变量。因为放变量，数组有可能越界访问非法内存

当[ ]里放变量：在这里插入图片描述

在一些编译器中，[ ]中放变量并不会报错，也可正常编译执行，那是因为该编译器支持C99语法标准。C99语法标准中，变长数组——[ ]中可以是变量。

2.一维数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。
全局数组和局部数组不给予初始化：

全局数组：系统默认初始化为0
局部数组：编译器给出未初始化的警告，在窗口里看到其被赋一些无意义的数。

在这里插入图片描述
其他：

arr5：字符串初始化数组，在监视中看到会多一个’\0’，所以有4个元素
arr6和arr7：单独放字符初始化数组，因为arr7是字符型数组，编译器会自动将98解析为字符('b’的ACSII码值为98)，arr6和arr7都是3个元素。

在这里插入图片描述

sizeof：计算的是数组的空间大小。arr5比arr6多一个’\0’，所以arr5的空间大小比arr6大1
strlen：计算的是字符的个数。strlen的结束标准是’\0’，且’\0’不计入字符个数。strlen(arr5)遇到’\0’就停止，长度为3；strlen(arr6)：abc后没有’\0’，那么strlen就会一直计算下去，直到遇到内存中的’\0’才停止。

2.一维数组的使用

数组的使用： [] ，下标引用操作符。它其实就是数组访问的操作符。我
们来看代码：

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };//数组的不完全初始化
    int sz = sizeof(arr) / sizeof(arr[0]);//计算数组的元素个数:10
    //对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：
    int i = 0;//做下标
    for (i = 0; i < sz; i++)//这里写10，好不好？
    {
        arr[i] = i;
    }
    //输出数组的内容
    for (i = 0; i < 10; ++i)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

运行结果：
在这里插入图片描述

总结:
1.数组是使用下标来访问的，下标从0开始。
2.数组的大小可通过计算得到。//int sz = sizeof(arr) / sizeof(arr[0]);

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

接下来我们探讨数组在内存中的存储。看代码：

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

运行结果：
在这里插入图片描述
可见，随着数组下标的增长，元素的地址，也在有规律的递增。可得结论：数组在内存中是连续存放的。
分析：
16进制与10进制的对应关系是：0-9对应0-9；A-F对应10-15。
地址都是16进制的，若转换成10进制，可见数组每个元素相差4(int整型变量的字节大小为4)，因此一维数组里的元素在内存中是连续存放的，且地址在不断增大。同理char类型的数组在内存中也是连续存放的，但每个元素应相差1(char类型变量的字节大小为1)。

总结：
1.一维数组在内存中是连续存放的
2.随着数组下标的增长，地址由低到高。

在这里插入图片描述

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

1.二维数组的创建

type_t arr_name[const_n][const_n]
//数组创建
int arr[3][5];//3行5列
char ch[4][7];//4行5列
double arr2[2][4]//2行4列

可见，二维数组的语法结构：类型+数组名+[行][列]，[ ]内放常量表达式。
当我们创建一个二维数组时，如int arr[3][4];后，我们可以理解如下图：在这里插入图片描述

2.二维数组的初始化

int main()
{	
	int arr1[3][4] = { 1,2,3,4,5,6,7,8,9,10 };//不完全初始化
	int arr2[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };//完全初始化
	return 0;
}

在这里插入图片描述

不完全初始化：没赋值的位置会自动赋值为0。
完全初始化：从头到尾将数值赋值给3×4的二维数组。
另外，从监视可看出，其实二维数组arr[3][4]是由三个一维数组构成且每个数组有4个元素(即一个一维数组有3个元素，而这3个元素的每一个元素内又含有4个元素)。

也可以用{ }来初始化：

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

在这里插入图片描述

二维数组看成多个一维数组，一个{ }对应一行(一个一维数组)，同样没有初始化的元素会自动赋值为0。

思考：当初始化个数大于数组定义的个数时，会发生什么？
如：int arr[2][4]; arr有2×4个元素，但初始化了9个数值。
在这里插入图片描述
编译报错，报错说明是初始值设定项太多，且无法执行。

解析：编译器会检查初始值设定项是否大于数组的长度。数组创建需要向内存申请空间，若初始值设定项占用的空间大于数组申请的空间，就会"访问越界"。(比如数组申请一块32个字节的空间，我们在初始化给了9个int类型的值，即36个字节，超过了数组本身可以访问的空间大小)。

给字符数组初始化也是一样的道理，但要注意\0

char ch1[2][4] = { 'a','b' };
char ch2[2][4] = { {'a'},{'b'} };
char ch3[3][4] = { "abc","def","gh" };

在这里插入图片描述
注：数组定义可省略行，但不可省略列。(下文解析)

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

3.二维数组的使用

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

#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++)//0~2行
	{
		int j = 0;
		for (j = 0; j < 4; j++)//0~3列
		{
			printf("%2d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

运行结果：
在这里插入图片描述

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

上面提到创建的二维数组可理解是一个二维的表(有行有列)，实际上呢？
像一维数组一样，这里我们尝试打印二维数组的每个元素。

#include <stdio.h>
int main()
{
	int arr[3][4];
	int i = 0;
	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]);
		}
	}
	return 0;
}

运行结果：
在这里插入图片描述
通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。
连续存储：1.每一行内部的元素连续存放 2.行与行之间连续存放
理解上的储存形式：

实际上的储存形式：

二维数组int arr[3][4];可看作由3个一维数组构成，这3个一维数组的数组名分别是arr[0]，arr[1]，arr[2]。
由数组访问成员的方式：数组名 + [下标]可知
若访问第一个一维数组中的第三个元素，即arr[0][2]
思考：二维数组在内存中是连续存放有什么作用？
1.上文提到int arr[][4];可省略行，但不可省略列。
原因：二维数组存储的时候是"先行后列", 如果不指定列数, 它就不能知道一行放几个数据了。只要知道了列数, 全部放完就可以知道一共能放多少行。
2.因为二维数组在内存中是连续存放的，当我们拿到二维数组的首地址时，就可以访问这个数组所有的元素。(联系指针有关知识，指针变量+1)
在这里插入图片描述

三、数组作为函数参数

我们在写代码的时候，往往会将数组作为参数传给函数。比如：我们要实现一个冒泡排序函数将一个整型数组排序。那我们将会这样使用函数：
冒泡排序函数的错误设计：

#include <stdio.h>
//冒泡排序函数的错误设计
void bubble_sort(int arr[])
{
    int sz = sizeof(arr) / sizeof(arr[0]);//这样对吗？
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        int j = 0;
        for (j = 0; j < sz - 1 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}
int main()
{
    int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
    int i = 0;
    bubble_sort(arr);//是否可以正常排序？
    for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

在这里插入图片描述
程序分析：调试之后可以看到bubble_sort函数内部的sz的值为1，arr的值为0x00cffd94(地址)。
小脑袋瓜在想：难道数组作为函数参的时候，不是把整个数组给传递过去吗？

四、关于数组名

数组名是什么？看代码：
在这里插入图片描述
结论：

数组名是数组首元素的地址。(但有两个例外)
①sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组。
②&数组名，取出的是数组的地址。&数组名，数组名表示整个数组。
除此①、②两种情况之外，所有的数组名都表示数组首元素的地址。

了解上面知识，我们可设计正确的冒泡排序函数：
设计思路：当数组传参时，实际上只是把数组的首元素的地址给传递过去。
所以即使在函数参数部分写成数组的形式：int arr[ ]，它表示的依然是一个指针，即：int *arr。那么，bubble_sort函数内部的sizeof(arr)的结果是4。既然在bubble_sort函数内部计算sz不行，那么就在main主函数内计算sz，这时sizeof(arr)计算是整个数组的大小，再将sz传给函数，这样问题就解决啦！

void bubble_sort(int arr[], int sz)//参数接收数组元素个数
{
 //...
}
int main()
{
    int arr[] = {3,1,7,5,8,9,0,2,4,6};
    int sz = sizeof(arr)/sizeof(arr[0]);
    bubble_sort(arr, sz);//是否可以正常排序？
    for(i=0; i<sz; i++)
   {
        printf("%d ", arr[i]);
   }
    return 0;
}