C语言第四课，数组

1. 一维数组

数组的创建和初始化

数组是一组相同类型元素的集合。数组创建的同时给一些初始值，这个过程叫初始化
一维数组的创建和初始化：

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int arr[5] = { 0 };//创建的5个元素，每一个元素都是int类型的，创建的时候给一些初始值的过程叫初始化。
	int arr[10] = { 1,2,3 };//前三个初始化1 2 3 ，剩余的都是0。这叫不完全初始化
	return 0;
}

char ch[b];这样的代码会报错，因为必须是一个常量。
c99标准之前，是不支持使用变量的，只能是常量。
c99中，添加了变长数组的概念，允许数组的大小是变量，而且要求编译器支持c99标准。vs对c99的支持就不好。

这里要再次深刻地理解一下strlen和sizeof函数。
strlen计算的是字符串的长度，关注字符串中是否由\0，计算的是\0之前的字符个数。
sizeof计算变量所占内存空间大小，只关注空间大小，不在乎\0。

int main()
{
	char arr1[] = { 'a','b','c' };
	//arr有3个元素，数组的大小是3个字节
	printf("%d\n", strlen(arr1));//随机值，15
	printf("%d\n", sizeof(arr1));//3
	
	char arr2[] = "abc";
	//arr2有四个元素，数组的大小是四个字节。
	printf("%d\n", strlen(arr2));//3
	printf("%d\n", sizeof(arr2));//4
	return 0;
}

一维数组的使用

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

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//下标：      
	printf("%d\n", arr[5]);//[]下标访问操作符，结果为6

	//计算数组元素的个数：
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

总结:

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

一维数组在内存中的存储

接下来对以下代码进行调试，看一看它在内存中的存储。

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

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

2 二维数组

二维数组的创建和初始化

int main()
{
	int arr[3][4] = { 0 };
	int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};//初始化
	int arr[3][4] = {1 ,2,3,4,5,6,};//不完全初始化
	int arr[][4] = {1,2,3,4,5,6,7,8,9,10,11,12};//行可以省略，列不能省略
	return 0;
}

二维数组在内存中的存储

初始化的时候，先把第一行的放完，再放第二行。
数据看似是分三行存放的，其实他就是一行存放的，而且是连续的。

二维数组的访问

int main()
{
 	int arr[3][4] = {0};
 	int i = 0;
	for(i=0; i<3; i++)
 	{
 		int j = 0;
 		for(j=0; j<4; j++)
 		{
 			arr[i][j] = i*4+j;
  		}
	 }
	for(i=0; i<3; i++)
 	{
 		int j = 0;
 		for(j=0; j<4; j++)
 		{
 			printf("%d ", arr[i][j]);//要访问的话，第一个元素的下标是arr[0][0]
 		}
 	}
 	return 0;
}

数组越界

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

int main()
{
	int arr[10] = { 0 };
	for (int i = 0; i <= 10; i++)
	{
		arr[i] = i;
	}
	printf("%d ", arr[10]);
	return 0;
}

这里发现数组越界了，会发生报错。

c语言是支持多维数组的，但是使用的场景很少。

int main()
{
	int arr[2][3][4];

	return 0;
}

数组作为函数参数

往往我们在写代码的时候，会将数组作为参数传个函数，
比如：我要实现一个冒泡排序（这里要讲算法思想）
函数将一个整形数组排序。那我们将会这样使用该函数。

冒泡排序的思想：
两两相邻的元素进行比较，如果可能的话，需要交换
例如：9 8 7 6 5 4 3 2 1 0我要使用冒泡升序
8 9 7 6 5 4 3 2 1 0（8 9交换）
8 7 9 6 5 4 3 2 1 0（9 7交换）
。。。
8 7 6 5 4 3 2 1 0 9 这一组比较完了，最大的数字9，来到了最后

7 8 6 5 4 3 2 1 0 9
一趟冒泡排序搞定一个数字，让当前待排序的数组中的一个元素来到最终应该出现的位置上

如果有n个数字，需要n-1趟冒泡排序。

第一趟排序完成之后，待排序的对象就少了一个
第二趟排序完成之后，待排序的对象就少了两个
……

冒泡函数的设计

//传过来的是数组的首元素地址。
void bubble_sort(int arr[],int sz)
{
	for (int i = 0; i < sz-1; i++)
	{
		//一趟冒泡排序的过程
		for (int j = 0; j <sz-1-i ; j++)
		{
			//一趟冒泡排序比较的对数
			if (arr[j] > arr[j + 1])
			{
				//交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	//数组传参
	int arr[10] = { 3,1,5,2,4,9,0,7,6,8};
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz);//实际上，数组传参传递的不是整个数组，而是首元素的地址，
	//按照这个地址，依然可以找到其他的元素
	printf("%d\n", sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

数组名

先上代码：

int main()
{
	int arr[] = { 1,2,3,4,5 };
	printf("%p\n", arr);//arr是数组首元素的地址
	printf("%p\n", &arr[0]);//数组首元素的地址
	printf("%p\n", &arr);
	//值看起来一样，但是意义不一样！！
	
	printf("%d\n",sizeof(arr));//20
	printf("%p\n", arr+1);
	printf("%p\n", &arr[0]+1);
	printf("%p\n", &arr+1);//跳过了整个数组
}

运行结果如下：

数组名是首元素地址,但是两种情况除外
1 sizeof内部单独存放在一个数组名，数组名表示整个数组，sizeof（数组名）计算的是整个数组的大小。
2 &数组名，取出的是数组的地址。&数组名，数组名表示整个数组。

例如printf(“%p\n”, &arr+1);
&arr表示整个数组的地址，他的值和数组首元素地址是一样的，但是区别在于数组地址加了一个1，跳过了整个数组。数组首元素地址+1，只跳过4个字节。

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

点击这里