数组（C）

1. 数组的概念

数组数组，就是一组相同类型元素的集合；精炼一下信息，可以有以下两点：

1. 数组中存放的元素个数不能为零；
2. 数组中存放的多个数据，类型是相同的。

数组分为一维数组和多维数组，多维数组一般是比较多见的二维数组。

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

2.1 数组创建

一维数组创建的基本语法如下：

1.  type arr_name(常量值);

存放在数组的值被称为数组的元素，数组在创建的时候可以指定数组的大小和数组的元素类型。

• type 指定的是数组中存放数据的类型，可以是： char、short、int、float等，也可以是自定义的类型。
• arr_name 指的是数组的名字，这个名字根据实际情况，起的有意义就行。
• [ ] 中的常量是用来指定数组的大小的，这个数组的大小根据实际的需求而定。

比如：我们现在想存储某班30人的英语成绩，我们可以创造一个数组，如下：

1. int math[30]

 2.2 数组的初始化

有时候，数组在创建的时候，我们需要个一些初始值，这种就被称为初始化。

数组的初始化一般使用大括号，讲数据放在大括号里。如下：

1. int math{30}

当然我们也可以根据需要来创造一些其他类型大小和数量的数组。

1. //完全初始化
2. int arr[5] = {1,2,3,4,5}:
3.
4.
5. //不完全初始化
6. int arr[6]={1};//第一个元素初始化为1，剩下的元素默认初始化0
7.
8. // 错误的初始化-初始化项太多
9. int arr[3] = {1,2,3,4};

2.3 数组的原型

数组也是有类型的，数组算是一种自定义类型，去掉数组名留下的就是数组的类型。

如下：

1. int arr1[10];
2.
3. int arr2[12];
4. 
5. char ch[5];

arr1数组的类型是 int [10];

arr2数组的类型是 int[12];

ch 数组的类型是 char [5];

3. 一维数组的使用

3.1 数组下标

C语言规定数组是有下标的，下标是从0开始的，假设数组有n个元素，最后一个元素的下标是n-1，下标就相当于数组元素的编号，如：

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

在C语言中数组的访问提供了一个操作符 [ ], 这个操作符叫：下标引用操作符。

有了下标访问操作符，我们就可以轻松地访问到数组的元素了，比如我们访问下标为7的元素，我们就可以使用 arr[7]，想要访问下标是3的元素，就可以使用arr[3],如下代码：

1. #include<stdio.h>
2. int main()
3. {
4.  	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
5.  	printf("%d\n", arr[7]);
6.  	printf("%d\n", arr[3]);
7.  	return 0;
8. }

输出结果：

3.2 数组元素的打印

如果我们要想访问整个数组的元素，仅仅需要使用下标加循环遍历数组就行，如下：

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

 输出结果：

3.3 数组的输入

当我们了解如何去打印数组的时候，那我们就想自己去改变数组的元素 ，如下：

1.  #include<stdio.h>
2.  int main()
3.  {
4.  	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
5.  	int i = 0;
6.  	for (i = 0; i < 10; i++)
7.  	{
8.  		scanf("%d", &arr[i]);
9.  	}
10. 	for (i=0;i<10;i++)
11. 	{
12. 		printf("%d ", arr[i]);
13. 	}
14. 	return 0;
15. }

输出结果：

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

前面已经学会了如何去使用数组，那么现在在来看一下深层次的，如数组在内存中是如何存储的。

依次打印数组的地址：

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

输出结果：

由此来看，数组随着下标的增长，地址是从小到大的，并且我们发现每两个相邻元素之间相差4个字节（一个整型是四个字节） 。

结论：数组在内存中是连续存放的。

5. sizeof计算数组元素个数 

sizeof是C语言中的一个关键字，用来计算类型或变量大小的。也可以用来计算数组的大小。

例如：

1.  #include<stdio.h>
2.  int main()
3.  {
4.  	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
5.  	printf("%d", sizeof(arr));
6.  	return 0;
7.  }

打印结果：

输出结果为40，单位为字节，计算的是数组所占内存空间的大小。

因为数组中元素的类型是一样的，计算出一个字节所占的内存大小就可以计算出数组中元素的个数。

1.  #include<stdio.h>
2.  int main()
3.  {
4.  	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
5.  	printf("%d", sizeof(arr[0]));
6.  	return 0;
7.  }

 输出结果：

接下来计算元素个数：

1.  #include<stdio.h>
2.  int main()
3.  {
4.  	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
5.  	printf("%d ", sizeof(arr) / sizeof(arr[0]));
6.  	return  0;
7.  }

 输出结果显示为10，证明数组中元素个数为10。这样写代码时就不用直接给定数组个数，代码变得多样。

6. 二维数组的创建

6.1 二维数组的概念

        一维数组中的元素都是有内置类型的，如果我们把一维数组作为数组的元素，就是二维数组。二维数组是一种数据类型，可以存储多行和多列的数据。它由一系列的行和列组成，每个元素都可以通过一个行索引和列索引来访问。二维数组作为数组元素被称为三维数组，二维以上的数组统称为多维数组。

6.2 二维数组的创建

语法：

1. type arr_name[常量值1][常量值2];
2. 例：
3. int arr[3][5];

•  3表示有三行
• 5表示有5列
• int表示数组的每个元素都是整型
• arr是数组名，可以根据自己需要指定名字。

7. 二维数组的初始化

在创建变量或者数组的时候，给定一些初始值，被称为初始化。

7.1 不完全初始化

1. int arr1[3][5] = { 1,2 };
2. int arr2[3][5] = { 0 };

7.2 完全初始化

1.	int arr3[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };

 

7.3 按照行初始化

1. int arr4[3][5] = {(1,2),(3,4),(5,6)};

 

7.4 初始化时省略行，但是不能省略列

1.  int arr5[][5] = { 1,2,3 };
2.  int arr6[][5] = { 1,2,3,4,5,6,7 };
3.  int arr7[][5] = { {1,2},{3,4},{5,6} };

8. 二维数组的使用

8.1 二维数组的下标

二维数组也是使用下标形式的，二维数组是有行和列的，只要锁定了行和列就能唯一锁定数组中的一个元素。

C语言规定，二维数组的行是从0开始的，列也是从0开始的，如下所示：

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

图中最右侧绿色数字表示行号，第一行蓝色的数字表示列号，都是从0开始的，比如，第二行，第4列，就可以快速定位出7.

1.  #include<stdio.h>
2.  int main()
3.  {
4.  	int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
5.  	printf("%d\n", arr[2][4]);
6.  	return 0;
7.  }

8.2 二维数组的输入和输出

我们可以按照一定规律产生所有的行和列的数字就行；

如：

1.  #include<stdio.h>
2.  int main()
3.  {
4.  	int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
5.  	int i = 0;
6.  	for (i = 0; i < 3; i++)//产生行号
7.  	{
8.  		int j = 0;
9.  		for (j = 0; j < 5; j++)
10. 		{
11. 			scanf("%d", &arr[i][j]);
12. 		}
13. 	}
14. 	for (i = 0; i < 3; i++)
15. 	{
16. 		int j = 0;
17. 		for (j = 0; j < 5; j++)
18. 		{
19. 			printf("%d", arr[i][j]);
20. 		}
21. 		printf("\n");
22. 	}
23. 	return 0;
24. }

 输出结果：

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

像一维数组一样，我们如果想研究二维数组在内存中的储存方式，我们也是可以打印出数组中所有元素的地址的。如：

1.  #include<stdio.h>
2.  int main()
3.  {
4.  	int arr[3][5] = { 0 };
5.  	int i = 0;
6.  	int j = 0;
7.  	for (i = 0; i < 3; i++)
8.  	{
9.  		for (j = 0; j < 5; j++)
10. 		{
11. 			printf("&arr[%d][%d]=%p\n", i, j, &arr[i][j]);
12. 		}
13. 	}
14. }

 输出结果：

从输出的结果来看，每一行内部的每个元素都是相邻的，地址之间相差4个字节，跨行位置处的两个元素（如：arr[0][4]和arr[1][0]）之间也是差4个字节，所以二维数组中的每个元素都是连续存在的。

如：

 10. C99中的变长数组

在C99标准之前，C语言在创建数组时，数组大小的指定只能使用常量，常量表达式，或者如果我们初始化数据的话，可以省略数组大小。

如： 

1.  int arr1[10];
2.  int arr2[3 + 5];
3.  int arr3[] = { 1,2,3 };

这样的语法限制，让我们创建数组就不够灵活，有时候数组大了浪费时间，有时候数组又小了不够用。

C语言给定一个变长数组的新特性，允许我们可以使用变量指定数组大小。

例：

1. int n = a+b;
int arr[n];

上面示例中，数组arr就是变长数组，因为它的长度取决于变量n的值，编译器没法事先确定，只有运行时才能知道n是多少。

变长数组的根本特征，就是数组长度只有在运行时才能确定，所以变长数组不能初始化。它的好处是程序员不必在开发时，随意为数组指定一个估计的长度，程序可以在运行时为数组分配精确的长度。有一个比较迷惑的点，变长数组的意思是数组的大小是可以使用变量来指定的，在程序运行的时候，根据变量的大小来指定元素的个数，而不是说数组的大小是可变的，数组的大小一旦确定就不能再变化了。