C语言数组详解

1.一维数组

1.1数组的创建

数组是一组相同类型元素的集合。和变量一样，在创建时也需要指定其类型。例如 int 类型数组，就代表这个数组中放的全是 int 。
数组创建的实例：

//代码一
int arr1[10];
//代码二
int count=10;
int arr2[count];  //arr2能够创建成功吗？
//代码三
char arr3[10];
float arr4[1];
double arr5[20];

代码一和代码三能够成功地创建数组，但是代码三却不行，这是因为在创建数组时[ ]中必须是一个常量，也就是数字，而count是一个变量，所以创建失败。

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[5] = { 'a','b','c' };
	char arr6[] = "abcdef";

数组在创建的时候如果不想指定数组的大小就必须得对数组初始化，数组的元素个数根据初始化的内容来确定。但是对于以下代码要区分其在内存中如何分配：

	char arr1[]="abc";          // a b c \0
	char arr2[3]={'a','b','c'}; // a b c

1.3一维数组的使用

#include <stdio.h>
int main()
{
	int arr[10]={0};//数组的不完全初始化
	//计算数组的元素个数
	int sz = sizeof(arr)/sizeof(arr[0]);
	//对数组内容赋值，数组是通过使用下标来访问的，下标从0开始。
	int i=0;//做下标
	for(i=0;i<sz;i++)
	{
		arr[i]=i;
	}
	//输出数组的内容
	for(i=0;i<sz;i++)
	{
		printf("%d ",arr[i]);
	}
	return 0;
}

输出结果如下：

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

	int arr[10]={0};
	int sz = sizeof(arr)/ziseof(arr[0]);

1.4一维数组在内存中的存储

接下来我们探讨数组在内存中的存储。

int main()
{
	int arr[10] = { 0 };
	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;
}

输出结果如下：

可见，一维数组在内存中是连续存放的

2.二维数组

二维数组的创建与初始化

//二维数组的创建并对其初始化
int arr1[3][4]={1,2,3,4};// 1 2 3 4
						 // 0 0 0 0 
						 // 0 0 0 0
int arr2[3][4]={{1,2},{4,5}}; // 1 2 0 0 
							  // 4 5 0 0
							  // 0 0 0 0
int arr3[][4]={{2,3},{4,5}}; // 2 3 0 0 
							 // 4 5 0 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++)
	{
		for (int j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
	}
	return 0;
}

输出结果如下:

二维数组在内存中的存储

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

可见，二维数组在内存中也是连续存储的。

3.数组越界

数组的下标是有范围限制的。数组的下标规定从0开始，如果有n个元素，那最后一个元素的下标就是n-1。所以数组的下标如果小于0或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。

4.数组作为函数参数(以冒泡排序为例)

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

4.1冒泡排序的错误设计

void bubble_sort(int arr[])//数组名作为函数参数传参，传递过来的是首元素地址。
{
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);//求数组元素个数，sz=1
	for (i = 0; i < sz - 1; i++)//外层函数确定冒泡排序的趟数
	{
		int j = 0;
		for (j = 0; j < sz - i - 1;j++)//内层循环确定每趟比较的次数 
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
int main()
{
	int arr[] = { 3,9,4,6,5,7,8,1,0,2 };
	bubble_sort(arr);//实际传递的是首元素地址，避免造成空间浪费
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

4.2数组名是什么？

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

输出结果：

结论：数组名是数组的首元素地址。
但是有两个例外：
1.sizeof(数组名)，计算的是整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组
2.&数组名，取出的是整个数组的地址
除此两种情况之外，所有的数组名都表示数组首元素的地址

4.3冒泡排序的正确设计

void bubble_sort(int arr[],int sz)
{
	//同上面函数代码
}
int main()
{
	int arr[] = { 3,9,4,6,5,7,8,1,0,2 };
	bubble_sort(arr,sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}