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

1.1 数组的创建

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

例如：

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[100] = { 0 };
//  数组类型 数组名 [数组个数]= {};
	return 0;
}

int main()
{
	const int m = 20;//常变量
	int n = 10;
	int arr[n];
	//C99中引入了边长数组的概念，允许数组的大小用变量来指定，如果编译器不支持C99中的变长数组，那就不能使用
	return 0;
}

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

1.2 数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）

int arr1[10] = {1,2,3};
int arr2[] = {1,2,3,4};
int arr3[5] = {1，2，3，4，5}；
char arr4[3] = {'a',98, 'c'};
char arr5[] = {'a','b','c'};
char arr6[] = "abcdef";

int a;
int main()
{
	static int b;
	printf("%d\n", a);
	printf("%d\n", b);
	return 0;
}

对于全局变量和局部变量来说如果没有进行初始化，那么就会自定义为0

int main()
{
	char arr1[] = "abc";//存放了a b c \0
	char arr2[] = { 'a','b','c' };//存放了a b c
	char arr3[5] = "abc";//存放了a b c \0 \0
	char arr4[5] = { 'a','b','c' };//存放了a b c \0 \0
	return 0;
}

1.3 一维数组的使用

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

int main()
{
	int arr[100] = { 1,2,3 };
	int i = 0;
	for (i = 0; i < 100; i++)
	{
		arr[i] = i + 1;
	}
	for (i = 0; i < 100; i++)
	{
		printf("%d\n", arr[i]);
	}
	return 0;
}

int main()
{
	int arr[100] = { 1,2,3 };
	printf("%d\n", sizeof(arr));//400
	printf("%d\n", sizeof(arr[0]));//4
	int sz = sizeof(arr) / sizeof(arr[0]);//计算元素个数的写法
	printf("%d\n", sz);//100
	return 0;
}

由上面两个例子我们可以优化一下创建元素的代码

int main()
{
	int arr[100] = { 1,2,3 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		arr[i] = i + 1;
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", arr[i]);
	}
	return 0;
}

总结:

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

仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。
大家可以看见每个地址之间都相差4，因为一个整形元素占4个字节
由此可以得出结论：数组在内存中是连续存放的。
数组名是数组首元素的地址

2. 二维数组的创建和初始化

2.1 二维数组的创建

//数组创建
int arr[3][4];
char arr[3][5];
double arr[2][4];

2.2 二维数组的初始化

int main()
{
	int arr1[3][5] = { 1,2,3,4,5,6 };//不完全初始化，初始化：3行5列
	int arr2[3][6] = { {1,2}, {4,5}, {5,6} };//第一行放1，2.第二行放4,5...
	return 0;
}

2.3 二维数组的使用

二维数组的使用也是通过下标的方式

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

2.4 二维数组在内存中的存储

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

3. 数组越界

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;
}

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

4. 数组作为函数参数

往往我们在写代码的时候，会将数组作为参数传个函数，比如：我要实现一个冒泡排序

4.1 冒泡排序函数的错误设计

void bubble_sort(int arr[])
{
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		//每一趟冒泡排序过程
		int j = 0;
		for (j = 0; j < sz-1-i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				//交换
				int tmp = arr[j];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	bubble_sort(arr);
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

当我们调试代码时会发现，数组中的数并没有进行排序，这是为什么呢？
出问题，那我们找一下问题，调试之后可以看到 bubble_sort 函数内部的 sz ，是1。

难道数组作为函数参数的时候，不是把整个数组的传递过去？

这个时候我们就有必要知道数组名是什么啦？

4.2 数组名是什么？

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

不难看出数组名就是数组首元素的地址

但是也会有例外

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%p\n", arr);//首元素的地址
	printf("%p\n", &arr[0]);//首元素的地址

	printf("%p\n", &arr);//数组的地址
	printf("%d\n", sizeof(arr));//整个数组所占得位置，40
	return 0;
}

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%p\n", arr);//首元素的地址
	printf("%p\n", arr+1);
	printf("\n");
	printf("%p\n", &arr[0]);//首元素的地址
	printf("%p\n", &arr[0]+1);
	printf("\n");
	printf("%p\n", &arr);//数组的地址
	printf("%p\n", &arr+1);
	return 0;
}

4.3 冒泡排序函数的正确设计

当数组传参的时候，实际上只是把数组的首元素的地址传递过去了。
所以即使在函数参数部分写成数组的形式： int arr[] 表示的依然是一个指针： int *arr 。
那么，函数内部的 sizeof(arr) 结果是4。
所以改成正确的代码为：

//void bubble_sort(int * arr)
void bubble_sort(int arr[],int sz)
{
	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 tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 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 < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

void bubble_sort(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;//假设已经有序
		//每一趟冒泡排序过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				flag = 0;
				//交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
		if (1 == flag)
		{
			break;
		}
	}
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}