这种写法只能在支持C99标准的编译器环境下能编译。在C99标准之前， [] 中要给一个常量才可

1.2数组的初始化

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

我们发现，其中有些数组[ ]中没有指定数组大小，但是这种写法也是正确的。是因为：

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

1.3一维数组的使用

在数组的使用之前，我曾在第一篇博客中介绍过数组和一个操作符：[ ]，下标引用操作符。（附上

接着我们用for循环对数组进行初始化，使得数组的内容为数字0~9

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

?不难理解，这串代码的作用是在屏幕上展示数组每个元素的地址，结果如下：

?仔细观察我们发现，数组中每两个相邻的元素地址相差 4 （十六进制形式表现），正好是一个int类型的大小。而且随着下标的增长，元素的地址也有递增的规律。

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

2.1二维数组的创建

2.2二维数组的初始化

注意这个特殊的写法，二维数组初始化时，行可以省略，列不能省略。

2.3二维数组的使用

?如果到这里我们对二维数组的结构还不太清楚的话，接着来看一看二维数组在内存中的存储。

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

#include <stdio.h>
int main()
{
	int arr[3][4];
	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;
}

输出结果如下：

?仔细观察我们发现，二维数组中每行元素里相邻的两个元素地址相差 4，正好为int类型大小。

且每一行最后的一个元素与下一行开头的元素地址也相差 4。

通过分析我们得出结论：二维数组在内存中也是连续存储的。

3.数组越界

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

数组的下规定是从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;
}

数组越界访问，我们无法知道使用越界访问的空间是否存在危险，是否有其他作用。所以可能带来

无法预料的后果。

这是一个曾难道万千程序员的难题：
?

#include <stdio.h>
int main()
{
? ? int i = 0;
? ? int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
? ? for (i = 0; i <= 12; i++)
? ? {
? ? ? ? arr[i] = 0;
? ? ? ? printf("hello world\n");
? ? }
? ? return 0;
}

//请问这串代码执行后的结果是什么？

令人意想不到的答案是：程序会死循环。

有的小伙伴可能想我之前一样绞尽脑汁都想不出为问题出在哪里，其实这就是因为数组越界访问引

起的，我们用画图来解释一下：

?for循环中，i的内容是从0，一直增加到12，而数组只有10个空间，因此会越界
?

每次访问arr数组i号位置时，都会将该位置内容设置为0，当访问到arr[12]时，也会将该位置内容设

置为0，而该位置恰好为i的位置，即a[12]恰巧将i设置为0，因此造成死循环。

4.数组作为函数参数

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

整形数组排序。

那我们会这样使用该函数：

4.1冒泡排序的错误设计

//方法1：
#include <stdio.h>
void bubble_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 - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
	bubble_sort(arr);//是否可以正常排序？
????int i = 0;
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

当运行完上面代码后，我们发现该函数并不能帮我们完成任务。

调试之后可以看到 bubble_sort 函数内部的 sz ，是1。

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

这里我们就得认识一下数组名了。

4.2数组名是什么

我们用这样一段代码来查看：

#include <stdio.h>
int main()
{
?? ?int arr[10] = { 1,2,3,4,5 };
?? ?printf("arr: ? ? ? %p\n", arr);
?? ?printf("&arr[0]: ? %p\n", &arr[0]);
?? ?printf("arr[0]: ? ?%d\n", *arr);
?? ?//输出结果
?? ?return 0;
}

输出结果如下：

这里我们好像可以得出结论：

数组名是数组首元素的地址。

但如果数组名是首元素地址，那么：

int arr[10] = { 0 };
printf("%d\n", sizeof(arr));

这段代码输出结果为什么是40？

其实这句话有两个例外：

????????1. sizeof(数组名 ) ，计算整个数组的大小， sizeof 内部单独放一个数组名，数组名表示整个数

????????组。

????????

????????2. &数组名，取出的是数组的地址。 & 数组名，数组名表示整个数组。

除此 1,2 两种情况之外，所有的数组名都表示数组首元素的地址。

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

当数组传参的时候，实际上只是把数组的首元素的地址传递过去了。

所以即使在函数参数部分写成数组的形式： int arr[] 表示的依然是一个指针： int *arr 。

那么，函数内部的 sizeof(arr) 结果是 4 。

如果方法 1 错了，该怎么设计？

#include<stdio.h>
//方法2
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 - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	bubble_sort(arr, sz);//是否可以正常排序？
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

这样修改之后，我们就可以正常的使用这个函数了。

到这里数组的知识都介绍完了，如果有小伙伴想深入了解冒泡排序函数，可参照我的另外一篇博客

飞快的排序算法专题篇。

本章完！

[C++知识库]初阶c语言之【数组】详解

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

1.1数组如何创建