c语言---22 一维数组

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

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

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

数组创建的示例：

     //数组的基本的创建形式
	//元素类型 数组名 元素个数
	int arr[8];//数组名较arr，[8]表示里面想放8个元素，这8个元素每个元素都是什么类型呢？是int
	char ch[5];//数组名为ch，[5]表示里里面放5个元素，这5个元素的类型全都是char类型

错误创建：在创建的过程中使用了变量
c99语法支持变长数组（数组的大小是变量），但是vs2022不支持变长数组所以会报错。

数组创建，[]中要给一个常量才可以，不能使用变量
1.2 数组的初始化
数组的初始化是指在创建数组的同时给数组的内容一些合理初始值（初始化）。如：int a = 10;就是对数组进行初始化了。对于数组的初始化，分为完全初始化和不完全初始化

• 完全初始化

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

• 不完全初始化

int arr[10] = { 1,2,3,4,5 };//不完全初始化

有一点需要注意，如果在数组的定义里面，不对数组进行元素个数的指定，那么数组就会根据后面元素集合中的个数来确定元素的个数。如int arr2[] = {1,2,3,4,5};，元素集合的个数为5，所以数组大小就默认是5.
观察一下下列数组定义的具体情况：
数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。但是对于下面的代码要区分内存中如何分配

char ch1[5] = {'h','i'};
char ch2[] = { 'h','i' };
//利用字符串来进行初始化
char ch3[5] = "hi";//这个数组的前三个元素会放置"h"、"i"、"\0",剩下的不放的都是0（也可以理解为\0,，因为\0的ASCII码值也是0）
char ch4[] = "hi";//但是这个是根据字符串内容创建的空间，所以不会有多余的，就只会是"h"、"i"、"\0"

关于这两个的区别：
a、内容打印的区别：

char ch2[] = { 'h','i' };//这个是放进去"h"、"i"两个元素
char ch4[] = "hi";//这个会放进去"h"、"i"、"\0"三个元素

char ch4[] = "hi";是指给ch4开辟了一块空间，存放"h"、“i”、“\0"三个元素，但是这三个元素的前面是什么元素，这三个元素的后面又是什么元素，这些我们都不知道的。
char ch2[] = { 'h','i' }; 是指在开辟的空间里放置"h”、“i”，这个时候还是不知道这两个元素的前面放置的是什么，也不知道后面放置的是什么，所以在打印数组的内容的时候就会去找结束符"\0",啥时候找到就啥时候结束打印。
b、长度的区别
加上这两句代码验证一下：

char ch2[] = { 'h','i' };//这个是放进去"h"、"i"两个元素
char ch4[] = "hi";//这个会放进去"h"、"i"、"\0"三个元素
printf("%d\n", strlen(ch2));//随机值
printf("%d\n", strlen(ch4));//长度为2

2、一维数组的使用

对于数组的使用会涉及到一个操作符[ ]----下标引用操作符，它其实就是数组访问的操作符。

int main()
{
	int arr[10] = { 0 };//不完全初始化，第一位是0，剩下的元素默认都是0；这个将十个元素完全初始化为0是一样的
	arr[4] = 5;//将下标为4的元素值改为5
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);//求数组的长度
	for (i = 0; i < sz; i++)
	{
		printf("%d ",arr[i]);
	}
	return 0;
}

代码的运行结果如下：

0 0 0 0 5 0 0 0 0 0

总结：

• 数组是通过下标来访问的，下标是从0开始
• 数组的大小可以通过计算得到

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

int main()
{
	int arr[10] = { 0 };
	arr[4] = 5;
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);//求数组的长度
	for (i = 0; i < sz; i++)
	{
		printf("&arr[%d]=%p\n",i, &arr[i]);
		//%p是按照地址的格式打印---十六进制的打印（会将位补齐）
	}
	return 0;
}

&arr[0]=000000CA3CB3F8C8
&arr[1]=000000CA3CB3F8CC
&arr[2]=000000CA3CB3F8D0
&arr[3]=000000CA3CB3F8D4
&arr[4]=000000CA3CB3F8D8
&arr[5]=000000CA3CB3F8DC
&arr[6]=000000CA3CB3F8E0
&arr[7]=000000CA3CB3F8E4
&arr[8]=000000CA3CB3F8E8
&arr[9]=000000CA3CB3F8EC

每个地址与每个地址之间差4个字节，因为每一个整型元素是4个字节，所以两个整型元素之间差的大小一定是四个字节。从这个代码及代码的运行结果中我们可以看出：一维数组在内存中是连续存放的；随着数组下标的增长，地址是由低到高变化的；数组名是数组首元素的地址
十六进制打印与按照地址打印的区别：

printf("%x\n",0x12);
printf("%p\n",0x12);

12
0000000000000012

因为数组在内存中是连续存放的，所以才可以通过第一个元素的地址往后访问进而一一地拿到后面的每一个元素。代码如下：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10};
	int* p = arr;//数组名是数组首元素的地址,是地址，所以可以放到指针里面去；
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ",*p);
		p++;
	}
	return 0;
}

代码运行结果如下：

1 2 3 4 5 6 7 8 9 10