第四站：数组

#include<stdio.h>
int main()
{
	//arr6与arr7一模一样都是有3个元素，并且为a，b，c
	char arr6[3] = { 'a', 'b', 'c' };
	char arr7[] = { 'a', 'b', 'c' };
	
	char arr8[10] = "abc";//十个元素，前三个为abc,后面都为\0
	char arr9[] = "abc";//四个元素，前三个为abc，最后一个为\0
 
}

还有一种就是全局数组不初始化默认为0，局部数组不初始化为随机值，这一点与全局变量不初始化默认为0，局部变量不初始化为随机值是类似的。

下面是调用监视窗口查看全局数组a1和局部数组a的内容。

 还有这两个初始化一定要搞清楚他们的区别

#include
int main()
{
	char arr8[] = "abc";
	char arr9[] = {'a', 'b', 'c'};
 
	printf("%s\n", arr8);
	printf("%s\n", arr9);
 
}

arr8中有\0，arr9没有\0

运行结果为

3.一维数组的使用

 在之前我们提到过一个下标引用操作符 [ ],他其实就是数组访问的操作符。

1.数组都是由下标的，下标是从0开始的

2.[]下标引用操作符

下面是顺序打印数组的方法

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

下面是倒序打印数组，跳着打印数组

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

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

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

结果为

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

运行结果为

 我们也可以试一下这个代码，验证一下指针+i的地址与&arr[i]的地址

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = &arr[0];
	for (i = 0 ; i < sz; i++)
	{
		printf("%p -----%p\n", p+i, &arr[i]);
	}
	return 0;
}

运行结果为

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

我们调试进行监视， 可以得到他们的分布

我们再试试没有放满的

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

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

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

#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("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
		}
	}
 
	return 0;
}

结果为

 我们会发现，还是每个元素差四个字节

也就是说二维数组也是和一维数组一样线性连续存储的！如下图所示，前四个为第一行，中间为第二行，后面为第三行，我们可以把一个二维数组当成一个一维数组来理解

 那我们二维数组也就可以使用一维数组那样采用指针的方式来打印

#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("%d ", arr[i][j]);
		}
	}
	printf("\n");
	int* p = &arr[0][0];
	for (i = 0; i < 12; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

 输出结果为

 而且我们二维数组每一行都可以理解为一个一维数组，这个一维数组的数组名为arr[0],arr[1]......如下图所示

 所以二维数组也是一维数组的数组

所以我们的打印数组也可以这样进行

#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 < sizeof(arr)/sizeof(arr[0]); i++)
	{
		int j = 0;
		for (j = 0; j < sizeof(arr[0])/sizeof(arr[0][0]); j++)
		{
			printf("%d ", arr[i][j]);
		}
	}
}

 三、数组越界

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

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

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

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

#include <stdio.h>
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.关于冒泡排序的经典错误标准零分

那么什么是冒泡排序呢？

比如说我们想要对下面一组数据进行升序的话

 我们是这样想的，我们让9和8进行比较，如果9大于8，那么9和8进行交换，然后交换以后变成以下

此时我们让第二个和第三个位置数据继续进行比较，并进行交换。然后重复下去，直到最后会变成

我们发现9已经来到了他应该来到的最终位置，那么我们前面八个数还需要进行排序。我们继续采用相同的方法。我们会发现，前八个数字最终也会

 此时我们发现8也来到了他应该来到的最终位置.

不妨我们就将这称作一趟冒泡排序，每一趟冒泡排序都可以使得一个数放到他应该来到的最终位置

那么问题来了，如果有10个数字，那么需要多少趟？

显然为9趟，对于任意n个数字，只需n-1趟冒泡排序。

于是我们就有冒泡排序的一个基本框架了

 这里的for循环可以确定需要多少趟冒泡排序，而里面每一层都是一趟冒泡排序

那么一趟需要比较多少次呢？

我们回顾前面的那个案例，不难发现，第一趟，需要9次比较，第二趟需要8次比较，我们总结规律，n个元素需要n-i-1次比较。

由此得到代码实现如下所示

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void sort(int arr[])
{
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (int j = 0; j < sz - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = 0;
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 4,5,1,3,7,10,100,45,323,852};
	sort(arr);
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", arr[i]);
	}
	return 0;
}

 然而当我们进行运行的时候,我们发现结果并非我们所期望的

 并没有进行交换，这是为什么呢？其实问题就出在了sizeof，我们数组的传参传的其实是一个指针，而非整个数组，所以sizeof（arr）计算出来的并不是一个数组的长度，而是arr这个指针的大小，所以我们就应该将sz给放到主函数中，然后在传参的时候传入sz

代码实现如下

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void sort(int arr[],int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (int j = 0; j < sz - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = 0;
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 4,5,1,3,7,10,100,45,323,852};
	int sz = sizeof(arr) / sizeof(arr[0]);
	sort(arr,sz);
	int i;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", arr[i]);
	}
	return 0;
}

运行后结果为

可见符合我们的预期

2.数组名到底是什么呢

我们在冒泡排序中，数组名一会是指针，一会代表整个数组，一会代表首元素地址。相信到了这块很多人都晕了，数组名到底是什么呢？

（1）一般的，数组名是首元素地址

一般情况下数组名是首元素地址，那么很多人就更加困惑了，什么是非一般情况呢？先不要着急，我们先来看看数组名是首元素地址的案例

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

运行之后

#include
int main()
{
	int arr[10] = { 0 };
	printf("%d", sizeof(arr));
	return 0;
}

运行结果为

其实，sizeof（数组名），这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节

第二个特例，&数组名

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

运行结果为

 可见这里的数组名表示的是整个数组，&数组名取出的是数组的地址

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

运行后结果为

 可见，第一组+1后的地址是+4，第二组+1后的地址也是+4，而第三组+1后的地址是加了40

我们发现，虽然结果一样，也就是他们的起点一样，但是他们的含义不同，&arr+1是直接跳过整个数组，而前两者仅仅跳过一个元素。

3.再次研究冒泡排序

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void sort(int arr[],int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (int j = 0; j < sz - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = 0;
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 4,5,1,3,7,10,100,45,323,852};
	int sz = sizeof(arr) / sizeof(arr[0]);
	sort(arr,sz);
	int i;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", arr[i]);
	}
	return 0;
}

我们现在应该能够理解了这段代码中，为什么sz要放在主函数内部了，虽然我传的是一个数组名，但是此时的数组名代表着首元素地址，而我们的形参虽然人模狗样的写着一个数组，但是其实他本质上是一个指针。也就说我们可以将他改为一个指针变量。

我们可以将其改为指针试一试

void sort(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (int j = 0; j < sz - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = 0;
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

我们运行后，这个代码仍然是正确的，所以我们传数组可以使用一个指针来接受。当然我们也可以使用一个数组的形式来进行接受，这样其实更加便于初学者理解。

而我们传入一个指针以后，我们就可以对这个指针进行+1，而整型指针+1，向后移动4个字节。刚好就是下一个数据。所以采用指针可以顺藤摸瓜，拿到整个数组的值。

当然有人就有一些困惑了，为什么我们平时函数传参的时候是直接拷贝过去，而数组却是传地址呢？这一点大家可以思考以下，如果我有10000个元素的数组，那么我们还要传整个数组的话，那么对这对于计算机内存上，运行速度上都会产生极大的浪费。所以使用指针传参也是很合理的。

总结

本节主要讲解了数组的一些基本知识点，基本概念，以及数组传参时候的一些坑，如果对你有一些帮助的话，不要忘记点赞加收藏哦！！!