C语言之【数组】

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

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

1、数组的创建

int main()
{
	//代码1：
	int arr1[10];

	//代码2；
	int count = 10;
	int arr2[count];//  []中必须是常量表达式才可以
	//VS2019 VS2022等IDE不支持C99中的变长数组

	//C99标准之前 数组的大小只能是常量表达式
	//C99标准引入了变长数组的概念，使得在创建数组的时候可以使用变量，但是这样的数组不能初始化。

	//代码3：
	char arr3[10];
	float arr4[1];
	double arr5[20];
	
	return 0;
}

2、数组的初始化`

在创建数组的同时给数组的内容一些合理化的初始，即为初始化

初始化分为完全初始化和不完全初始化

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };//完全初始化
	int arr2[10] = { 1,2,3,4,5 };//不完全初始化,剩余的元素默认都是0
	int arr3[] = { 1,2,3,4,5 };//省略数组的大小的时候，数组必须初始化，
	                           //数组的大小是根据初始化的内容来决定的
	
	return 0;
}

需要注意的是

int main()
{
	char arr1[] = "abc";
	//字符串末尾隐藏了\0
	char arr2[] = { 'a','b','c' };
	char arr3[] = { 'a',98,'c' };
	//这里的arr2和arr3里存放的元素一样，b对应的ASSIC值是98
	return 0;
}

数组在创建的时候，如果不想指定数组的大小就得初始化。数组的元素个数根据初始化的内容来确定的。

3、一维数组的使用

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

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  //对应的数组下标：0 1 2 3 4 5 6 7 8 9

	//计算数组内的元素个数
	int sz = sizeof(arr) / sizeof(arr[0]);
	
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);//这里可以用变量，在C99标准之前数组在创建时不能用变量
	}
	return 0;
}

 总结：
1、数组是使用下标来访问的，下标从0开始。
2、数组的大小可以通过计算得到。

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

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

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

	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("&arr[%d] = %p\n", i, &arr[i]);// %p 是用来打印地址的
	}
	return 0;
}

仔细地观察输出我们知道：随着数组下标的增长，元素的地址也在有规律的递增。
由此可以得出结论：数组在内存中是连续存放的。

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

1、二维数组的创建

type_t arr_name[const_n][const_n];
type_t 代表数组的元素类型
arr_name 代表数组名
const_n 代表常量或常量表达式

如：
int arr1[4][5];
char arr2[5][3];
double arr3[2][4];

2、二维数组的初始化

int main()
{
	//数组的初始化
	int arr[4][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7},{5,6,7,8,9} };
	int arr2[4][5] = { {1,2,3 }, {2, 3, 4 }, {3, 4, 5, 6, 7}, {5, 6, 7, 8, 9} };
	//二维数组即使初始化的了
	//行是可以省略的，但是列是不能省略的
	int arr3[][5] = { {1,2,3 }, {2, 3, 4 }, {3, 4, 5, 6, 7}, {5, 6, 7, 8, 9} };

	return 0;
}

3、二维数组的使用

二维数组的使用也是通过下标来实现的

如果创建一个数组

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

画图表示

二维数组行和列都是从0开始
就比如arr[3][4]表示第3行第4列的元素8

int main()
{
	int arr[4][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7},{4,5,6,7,8} };
	//printf("%d\n", arr[2][3]);
	int i = 0;//行
	for (i = 0; i < 4; i++)
	{
		int j = 0;//列
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

运行结果：

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

像一维数组一样，我们尝试打印二维数组的每个元素

int main()
{
	int arr[4][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7},{4,5,6,7,8} };
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("&arr[%d][%d] = %p\n",i,j,&arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

代码运行结果：

通过结果我们可以分析到：二维数组在内存中也是连续存储的

二维数组是一维数组的数组

三、数组的越界

数组的下标是有范围限制的
数组的下标规定是从0开始的，如果数组有n个元素，最后一个下表就是n-1，所以数组的下标如果小于0，或者大于n-1.就是数组越界访问了，超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是并不意味着程序就是正确的。

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", arr[i]);//当i等于10的时候，就越界访问了。
	}
	return 0;
}

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

四、数组作为函数参数

1、数组名是什么

数组名通常情况下都是数组首元素的地址

int main()
{
	int arr[10] = { 0 };
	printf("arr的地址：%p\n", arr);
	printf("arr[0]的地址：%p\n", &arr[0]);
	return 0;
}

运行结果：

结果显而易见，首元素arrr[0]的地址与数组名arr的地址是同一个地址。

但是有两个例外
1、sizeof(数组名)，数组名单独放在sizeof( )内部，这里的数组名表示整个数组，计算整个数组的大小
2、&数组名，这里的数组名也表示整个数组，取出的是整个数组的地址
除此之外遇到的所有数组名都表示首元素的地址

2、冒泡排序函数

void Bubble_sort(int* arr,int sz)//这里的arr[10]本质还是指针变量  int* arr可以替换为 int arr[]
{
	int i = 0;
	for (i = 0; i < sz-1; i++)
	{
		int j = 0;
		int flag = 1;
		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] = temp;
				flag = 0;
			}
		}
		if (flag == 1)
			break;
	}
}

int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Bubble_sort(arr,sz);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

运行结果：