【C语言初阶】数组

目录：

1、一维数组的创建和初始化
2、一维数组的使用
3、一维数组在内存中的存储
4、二维数组的创建和初始化
5、二维数组的使用
6、二维数组在内存中的存储
7、数组越界
8、数组作为函数参数（冒泡排序）

---

 数组的大小和长度：

在C语言中，数组的大小通常可以用运算符sizeof（arr）来计算数组占内存大小。单位是字节。

数组的长度，通常使用strlen(arr)或者sizeof(arr)/sizeof(arr[0])来计算。单位是字符。

一、一维数组的创建和初始化

概念：一组相同类型元素的集合。

1、语法：

type_t     arr_name   [const_n];

type_t   是指数组的元素类型

const_n  是一个常量表达式，用来指定数组的大小。

2、数组的创建：

在创建数组时，必须定义数组的类型和大小，数组的大小不能为0，数组中的元素类型都相同

例如：

1、创建一个整型类型的数组。int arr[10];

2、创建一个字符型的数组。char  arr[10];

3、创建浮点型的数组。double  arr[10];

4、用表达式指定数组大小创建的数组。int  arr[3+2];

5、const_n中使用变量来指定数组的大小。c99中引入了变长数组的概念，变长数组支持数组的大小使用变量来指定， 变长数组不是数组的长度可以变化，而是数组的大小可以用变量来指定。变长数组不可以进行初始化。变长数组只有在支持c99标准的编译器环境下能编译
 在很多刷题平台上可以使用变长数组。
   

2、初始化：

 1、声明数组的时候不指定元素的个数，数组会跟据初始值的个数自动进行设定。

int  arr[ ]={1,2,3,4,5};    元素个数省略，会自动认为是5。

2、不完全初始化。

int  arr[5]={1,2,3,0,0};    只初始化前3个，剩余的用0来进行初始化。

3、用0来初始化数组中的全部元素。

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

4、不能通过赋值语言来进行初始化。例如：

int  arr[3];

arr={1,2,3};

5、初始值的个数不能超过数组的元素个数，否则程序会发生错误。

int  arr[3]={1,2,3,4};  这样写是错误的。

6、初始化也可以这样写

char arr[ ]="abcd";    这样初始化相当于在arr数组的内存空间中放了5个元素，其中包含\0。

char arr[ ]={'a','b','c'};  这样初始化arr数组中只放了3个元素。

char  arr[10]="abc";  这样初始化arr数组内存中初始化了4个元素。

---

 二、一维数组的使用

1、[ ]:下标引用操作符，它就是数组访问的操作符。

 举例：

#include<stdio.h>
int main()
{
	int arr[20] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
	
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);//计算数组的元素个数
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);//arr[i]表示数组的一个元素，而不是创建数组
	}    //输出下标为i的数
	return 0;
}

 上述的arr[i],表示访问下标为i的元素。

---

 三、一维数组在内存中的存储

先看代码：

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

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

输出结果如下：

   通过观察输出的结果：随着数组下标的增长，元素的地址，也在有规律的增长（每次增长4个内存单元的大小）。因为数组是int类型，占4个字节。（一个内存单元是一个字节）

结论： （1）、数组在内存中是连续存放的！

            （2）、随着数组下标的增长，地址也是由低到高变化的。

---

 四、二维数组的创建和初始化

1、二维数组的创建

 int arr[3][4];//表示数组arr有3行4列。

char arr[3][5];

double arr[2][4];

2、二维数组的初始化

int arr[3][4]={1,2,3,4,5}；//按顺序依次存放,第一行存完第二行，剩余的全部用0来初始化。

int arr[3][4]={{1,2},{3,4}};//指定第一行来存放1、2，第二行存放3、4，剩余用0来初始化。

int arr[ ][4]={2,3,4,5};//这样也是按顺序来初始化。

 二维数组的初始化，行可以省略，列不能省略 

二维数组arr[3][4],

这是我们理解的二维数组的排列。

---

 五、二维数组的使用

按行访问：

#include<stdio.h>
int main()
{
   int arr[3][4]={{1,2},{3,4},{5}};
   int i = 0;
   for (i = 0; i < 3; i++)
   {
	  int j = 0;
	  for (j = 0; j < 4; j++)
	   {
		  printf("%d ", arr[i][j]);
	   }
	printf("\n");//表示打印完一行换行
   }

	return 0;
}

 结果是：

---

 六、二维数组在内存中的存储

#include<stdio.h>
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++)
		{
			printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
		}
	}

	return 0;
}

 结果是：

 通过上述代码的输出结果，可以看出由于数组arr是整型类型每个元素之间都相差4个内存单元，所以二维数组在内存中也是连续存储的。

---

 七、数组越界

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

数组的下标规定从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。

所以数组的下标如果小于0，或者大于n-1,就是数组越界访问了，超出了数组合法空间的访问。

C语言本身是不做数组下标的越界检查，编辑器也不一定报错，但是编辑器不报错，并意味着程序就是正确的。

所以程序员写代码时，最好自己做越界检查。

 1、一维数组举例

#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 ", arr[i]);
	}

	return 0;
}

 结果为：

2、二维数组举例：列越界

#include<stdio.h>
int main()
{
	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 < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

 结果为：

 图示越界过程：

---

八、数组作为函数参数

将数组作为参数传给函数

1、冒泡排序

冒泡排序的思想：从数组头部开始，不断比较相邻的两个元素的大小，让较大的元素逐渐往后移动（交换两个元素的值），直到数组的末尾。经过第一轮的比较，就可以找到最大的元素，并将它移动到最后一个位置。按照这个思路进行多轮比较，最终数组按从小到大排序。 

画图体现：

 代码实现：

#include<stdio.h>
//void bubble_sort(int* arr)//数组的形参就是指针变量来接收
void bubble_sort(int arr[], int sz)//在这里arr[]作为形参，本质应为指针变量int* arr
{
	//求数组的元素个数
	//int sz = sizeof(arr) / sizeof(arr[0]);//err  在这里sizeof(arr) / sizeof(arr[0])表示 
    //的是数组首元素地址（x86的环境下，结果是4）/第一个元素的大小（4）得到的是1
	
	//冒泡排序的趟数
	int i = 0;
	for (i = 0; i < sz-1; i++)
	{
		//一趟冒泡排序
		int j = 0;
		for (j = 0; j < sz-1-i; j++)//每趟交换的次数j<sz-1-i表示比较次数比数组元素个数少1， 
                                   //每进行完一趟，相应少比较i次，用sz-1-i就是每趟交换的次数
		{
			if (arr[j] > arr[j + 1])		
        	{

			    int tmp = arr[j];
				arr[j] = arr[j + 1];//交换位置
				arr[j + 1] = tmp;
			}
		}
	}
}

int main()
{
	int arr[10] = {1,3,5,7,9,2,4,6,8,0};
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);//实参arr传递的是数组首地址，数组传参的时候，写的是数组名，数组名本 
                         //质是数组首元素地址,传参的时候就是数组首元素的地址，那么数组的形参 
                         //就应该是指针变量来接收
	//打印
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

 结果为：

 注释：

形参在接收时本质是用指针变量来接收，指针变量接受的就是地址

用数组来接收是因为，数组传参的时候，写的是数组名，数组名本质是数组的首元素地址，传参的时候就是数组首元素的地址。

所以在本质上两种是相同的。