数组的一些详细介绍，适合初学

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

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

type_t arr_name [const_n];
type_t 是指数组的元素类型
const_n 是一个常量表达式，用来指定数组的大小

一些例子：

int arr1[10];

int count = 10;
int arr2[count];//数组时候可以正常创建？
//答案是不可以的，有我上面给的数组定义就知道，数组的大小只能常量不能变量

char arr3[10];
float arr4[1];
double arr5[10]

数组的初始化

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

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

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

另外数组既不初始化又不指定大小这样的写法绝对是错误的。

但是对于下面的代码要区分，内存中如何分配。

char arr1[] = “abc”;
char arr2[3] = {‘a’,‘b’,‘c’};

死一个的大小是4，因为存放了abc\0

2. 一维数组的使用

一维数组中我们使用下标来访问每个元素。

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

1.而下标是从零开始的
2.并且数组元素的个数可以通过sizeof来计算得到

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


	return 0;
}

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

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

打印结果：

arr[0] = 0061FB60
arr[1] = 0061FB64
arr[2] = 0061FB68
arr[3] = 0061FB6C
arr[4] = 0061FB70
arr[5] = 0061FB74
arr[6] = 0061FB78
arr[7] = 0061FB7C
arr[8] = 0061FB80
arr[9] = 0061FB84

通过此打印结果可知内存是连续存放的，并且随着下标的增长的，地址是由低到高变化

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

二维数组的创建

	int arr[3][5] ;
	char arr[4][6];
	double d[4][7];

二维数组的初始化

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

这个函数的初始化就是一个一个放进二维数组直到一行变满，再转到下一行。

int arr1[3][5] = { {1,2}, {3,4},{5,6} };

这样第一行就放12， 第二行就放3,4以此类推。

可能会有人问这个数组的行和列能否省略arr1[][],
答案是不能的，二维数组能省略行，但是列是绝对不能省略的。

int arr1[][5] = { {1,2}, {3,4},{5,6} };

所以一个问题，请问不初始化能否省略行？
答案是不行的，会报错。因为我们是根据后面初始化的内容来确定有多少行。

而字符也是一样，第一行放满到第二行依次进行，

char arr[4][6] = {'a', 'b'};

下面这个就是初始化两行

char arr1[4][6] = { {'a'}, {'b'} };

与此同时，这样写也是对的

char ch3[4][6] = { "abc", "def", "qwe" };

5. 二维数组的使用

二维数组的下标行和列都是从0开始

int main()
{
	int arr[3][5] = { {1, 2, 3}, {4, 5}, {6, 7, 8, 9,0} };
	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;
}

打印结果·：

1 2 3 0 0
4 5 0 0 0
6 7 8 9 0

接下来看看打印的二维数组地址：

int main()
{
	int arr[3][5] = { {1, 2, 3}, {4, 5}, {6, 7, 8, 9,0} };
	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]);

		}
		printf("\n");
	}

	return 0;
}

打印结果：

&arr[0][0] = 007DF73C
&arr[0][1] = 007DF740
&arr[0][2] = 007DF744
&arr[0][3] = 007DF748
&arr[0][4] = 007DF74C

&arr[1][0] = 007DF750
&arr[1][1] = 007DF754
&arr[1][2] = 007DF758
&arr[1][3] = 007DF75C
&arr[1][4] = 007DF760

&arr[2][0] = 007DF764
&arr[2][1] = 007DF768
&arr[2][2] = 007DF76C
&arr[2][3] = 007DF770
&arr[2][4] = 007DF774

可以看出都每个数组地址都差四个字节，且递增。
结论：
二维数组在内存中是连续
可以认为二维数组比如说 int arr[3][5]中有三个元素，每个元素都是一个一维数组。

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

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

	return 0;
}

打印结果：

006FF6CC
006FF6CC
1 2 3 4 5
1 2 3 4 5
可以看得出前两个打印首元素地址是一摸一样的，后面两个打印全部数组存储的东西也是一抹一样的。

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

	return 0;
}

而我们通过以上代码就可以那一个二维数组用一维数组的方式去看，他的打印结果是：

1 2 3 0 0 4 5 0 0 0 6 7 8 9 0

7. 数组作为函数参数

冒泡排序：
核心思想：两两相邻的元素进行比较

9 8 7 6 5 4 3 2 1
8 9 7 6 5 4 3 2 1
8 7 9 6 5 4 3 2 1
。。。
8 7 6 5 4 3 2 1 9

所以按照这些要求我写了一部分代码

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 (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[] = { 1, 4,2,3,8,7,5,6,9,0 };
	//排序
	//数组传参
	Sort(arr);
	Print(arr);

	return 0;
}

但是我发现运行不出来，这是什么原因呢，所以为了找出问题，我们来调试发现sz在函数Sort里面存放的是1，这是为什么？

第一：我们在main函数里传参的是arr首元素地址，既然是地址传过去那么Sort函数里面存放的就是指针， 本质上还是void Sort(int* arr)这样写也是对的，跟void Sort(int arr[])也是一样的，本质上都是指针，为了方便理解这样写。

第二：如果这是个指针，他在32位平台下就是四，那么sizeof(arr) = 4,而sizeof(arr[0])是int类型，那么也是4, 所以4/4 = 1；

修改完之后：

void 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[] = { 1, 4,2,3,8,7,5,6,9,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//排序
	//数组传参
	Sort(arr, sz);
	/*Print(arr);*/

	return 0;
}

调试完发现排序正确

优化：

Print(int* p, int* sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", p[i]);
		//printf("%d ", *p(i+1);//一样的
		//printf（"%d ", *p++);//一样的
	}
}
void Sort(int arr[], int sz)
{
	
	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 tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flag = 0;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}

int main()
{
	int arr[] = { 1, 4,2,3,8,7,5,6,9,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//排序
	//数组传参
	Sort(arr, sz);
	Print(arr, sz);

	return 0;
}

数组名是什么？

//数组名就是首元素的地址
//有两个例外
//1.sizeof（数组名），这里的数组名表示整个数组，sizeof（数组名）计算的就是整个数组的大小
//2. &数组名， 这里的数组表示的就是整个数组，取出的是数组的地址
//
//

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

	printf("%p\n", &arr);//数组的地址

	return 0;
}