《C语言精讲第八课》——数组,超级详细且容易理解

《C语言精讲第八课》——数组，超级详细且容易理解

前言

之前我们的程序中使用的变量都属于基本类型，例如整型、字符型、浮点型，这些都是简单的数据类型。对于简单的问题，使用这些简单的数据类型就可以了。但是，对于有些需要处理的数据，只用简单的数据类型是不够的，难以反映出数据的特点，也难以有效的处理。
例如：一个班有30个学生，要求这30名学生的平均成绩，，理论上很简单，把30个学生的成绩加起来，再除以30就行了，问题是怎样表示30个学生呢？下面，我们就介绍今天的重点：数组

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

1.1一维数组的创建

注意：数组是一组相同类型元素的集合！
要使用数组，必须现在程序中定义数组，即:由哪些数据组成数组，数组中有多少个元素，属于哪个数据类型，下面是对数组的定义：
数组的创建方式：

int arr_number[const n];
//int 是指数据的类型，根据数组里面的内容来定义数组的数据类型
//arr_number 是指数组名
//const n 是常量表达式，指数组中有多少个元素，必须是常量

数组创建的实例：

//代码1
int arr[10]; //数据类型为整型，数组名是arr，数组里面有10个元素，当然，类型也可以定义为char，short等，根据自身的需要
short num[5];
char ch[6];
float fun[5+3];
//在c99标准之前,[]必须是常量
//代码2
int n = 10;
int arr2[n];//在[]里面是变量，这样就是错误的
//但是，在C99之后，支持了变长数组的概念，数组的大小可以用变量指定，请看下面的分析：

在VS上面不支持变长数组的概念，运行起来会提示错误，但是在gcc编译器上支持边长数组，但是变长数组不能够初始化，大家也可以想一下，变长数组里面是一个变量，即可变的量，怎么能够初始化成固定的值呢！
注：数组创建，在C99标准之前，[]中要给一个常量才可以，不能使用变量。在C99标准支持了变长数组的概念，数组的大小可以使用变量指定，但是数组不能初始化。

1.2数组的初始

数组的初始化是指，在创建数组的同时，给数组的内容一些合理的初始值(初始化)
看代码：

int arr1[10] = {0,2,3,4,5,6,7,8,9};//完全初始化，对数组的全部元素赋予了初值
int arr2[10] = {0,1,2,3,4};//不完全初始化，剩余的默认初始化为0

char arr3[5] = { 'a', 'b',99 };//这里放个99是什么意思？
char arr5[5] = { 'a', 'b', 'c' };
int arr6[5] = "abcdef";

由此我们可以看看出，arr3中的99是‘c’的ASCII码值，字符在内存中存放的是对应的ASCII码值，打印出来的是字符！,其他的元素自动存储成0，对应的是‘\0’.

char ch1[] = {'a', 'b', 'c'};
char ch2[] = "abcdef";//这两个有什么区别呢？

区别：

在没有给数组指定的大小时，数组会根据初始化的内容自己定义大小，在ch2中总共有6个元素，字符串自带一个‘\0’，而在ch1中只有3个元素，没有‘\0’，所以当编译时，ch2就会打印出字符串“abcdef”,而ch1就会打印出未知的元素，直到遇见‘\0’为止！所以，当你给数组指定过大小后，数组的元素只能在规定的大小之内，如果没有规定大小，则要注意以上两种情况。

1.3一维数组的使用

在定义数组并对其中各元素赋值后，就可以引用数组中的元素，应注意：只能引用数组元素而不能一次整体调用整个数组全部元素的值。
对于数组的使用我们之前介绍了一个操作符[ ]，下标引用操作符。它其实就数组访问的操作符。
数组名[下标]

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

注意：数组的下标是从0开始的

[ ] 这个符号就是下标引用操作符，通过访问下标，就可以找到对应的元素。

要注意arr[i]中的字母i，这个i可不是我们所说的变长数组，而是为了连续访问数组的各个元素，而且，arr[i] 和arr[10] 中的[] 也不同，arr[i] 中的[] x是下标引用操作符，而arr[10]中的[]只是一种语法形式！这一点一定不要混淆。

int a = 10；
printf("%d", sizeof(a));
printf("%d", sizeof(int));

在求变量大小时，通常是sizeof(变量名)，但我们把变量名换成数据类型，同样可以求出它的大小，实际上求变量的大小就是通过数据类型推算出的，所以哪一种都可以求出大小。
同理：数组有没有数据类型呢？

int arr[10] = {1,2,3,4,5,6,7,8,9,10}  
printf("%d\n", sizeof(int));
printf("%d",sizeof(arr))

可以看到，不管是求sizeof(arr) 还是sizeof(int [10]) 得出的结果都一样，所以，数组也是有类型的，去掉数组名，剩下的就是数组的类型。

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

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

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

我们根据他们每个元素的地址可以看出，地址的最后以后数字都是相差4，我们知道，内存中进行存储时是以字节进行存储的，对于这个int型的数组来说，每个元素所占了4个字节，所以他们的地址也是相差4.因此可以得出，数组在内存中时连续存放的，且地址是由高到低。
数组的地址有什么用呢？

可以看到，当把数组的地址放入指针p里面之后，输出p+i的地址和&arr[i]的地址一样，当把数组中第一个元素的地址存放到p中之后，p+i就变成了从起始位置向后移动p+i个地址，比如p+1，就代表向后移动一个地址，因为每个元素之间相差4个字节，所以p+1就向后移动了4个字节。所以p+i=&arr[i]
所以当我们想要访问数组中的元素时，也可以写成

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

==注意：==在例子中，指针的类型是整型，所以p+1就是跳过一个整型指针，你是什么类型的指针，当p+1时就会跳过一个什么样的类型。
所以，当我们拿到第一个元素的地址时，顺藤摸瓜就能找到其他的元素。

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

2.1二维数组的创建

int arr1[3][4];
char arr2[5][6];
floar arr3[2][3];

二维数组的创建和一维数组的创建几乎一样，只不过二维数组分成了行和列，就相当于我们学习的线性代数一样。定义什么类型的数组，数组中的内容就是什么类型。

2.2二维数组的初始化

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,6}};
int arr2[][4] = {1,2,3,4,5,6,7,8,9,10,11,12};

对于二维数组的初始化，和一维数组唯一的不同就是它定义的列，
arr1中，三行四列总共12个元素，所以它会在每一行按元素的顺序规定，
arr2中，三行四列，对每一行的元素进行了规定，规定每一行只有2个元素，但 是，本身它是四列，所以每列应该有四个元素，所以剩下的两个元素补0.
arr3中，对行进行了省略，编译器会根据数组的内容对每一行进行分配，但是应注意，数组的行可以省略，但是列不能省略

2.3二维数组的使用

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

==注意：==数组每一行和每一列的下标是从0开始的，并不是从1，

	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++)//i<3是因为这个数组有三行，循环三次
	{
		int j = 0;
		for (j = 0; j < 4; j++)//j<4,这个数组有四列，循环四次
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}

当i=0时，进入内嵌循环，j=0时，打印arr[0] [0]的元素，j++，变成1，打印arr[0] [1]的元素。就这样一直循环，就能把整个数组打印出来。

提示：%2d表示域宽为2，不足两位数的前面补看i空格，这样，一位数就可一和两位数进行对齐。

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

像一维数组一样，这里我们尝试打印二维数组的每个元素的地址

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

根据二位数组中每一位元素的地址可以看到，每个地址的最后一位也是相差4个字节，所以每一行元素都是按顺序存储的

在换行的时候，第0行的最后一个元素和第一行的第一个元素的地址也是相差4个字节，所以由此可以得出，二位数组中每个元素都是由低到高顺序存储的，存完一行后再存下一行，这也是为什么二维数组只能省略行数而不能省略列数的原因，因为如果省略了列数，编译器就不知道这个元素应该从那个位置开始存储，但是只省略行数，编译器会根据你的元素个数自动分行。

附加知识点：
我们知道一维数组的形式是，例如：int arr[10] ,要访问数组中的元素时时arr[i] ,数组名加元素下标，所以我们也可以把二位数组的每一行看作一维数组。

如果把二维数组的每一行看作一维数组，那么每一行的一维数组也有数组名，
arr[0] 是第一行的数组名
arr[1] 是第二行的数组名
arr[2] 是第三行的数组名，以此类推。

🏁3.数组的越界

数组的下标是有范围限制的。
数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。
所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就
是正确的，
所以程序员写代码时，最好自己做越界的检查。

i 最大变成了10，当i= 10时，就造成了越界访问，编译器还可以正常运行，但是会给你一个提示，但是，在有些不太聪明的编译器上面是不会给出提示的，因此，程序员们一定要注意！
本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就
是正确的，
所以程序员写代码时，最好自己做越界的检查。