BIT-4-数组

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

1.1 数组的创建

数组是一组相同类型元素的集合。

数组的创建方式：

type_t   arr_name   [const_n];

//type_t 是指数组的元素类型

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

 数组创建的实例：

//代码1
int arr1[10];
//代码2
int count = 10;
int arr2[count];//数组时候可以正常创建？
//代码3
char arr3[10];
float arr4[1];
double arr5[20];

注：数组创建，在C99标准之前， [ ] 中要给一个常量才可以，不能使用变量。

在C99标准支持了变长数组的概念，数组的大小可以使用变量指定，但是数组不能初始化。（初始化数组内容）

但是在VS的编译器上是不支持变长数组的概念

1.2 数组的初始化

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

看代码：

int arr1[10] = {1,2,3};//不完全初始化，剩余的元素默认都是0
int arr2[] = {1,2,3,4};//省略数组大小，数组必须初始化，数组大小根据初始化决定，此处为4
int arr3[5] = {1，2，3，4，5}；//完全初始化
char arr4[3] = {'a',98, 'c'};//完全初始化
char arr5[] = {'a','b','c'};//省略数组大小，数组必须初始化，数组大小根据初始化决定，此处为3
char arr6[] = "abcdef";//

数组在初始化的时候要用{ }括号括起来，然后里面的值用，逗号隔开，

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

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

char arr1[] = "abc";//在数组中会多存入’\0‘
char arr2[3] = {'a','b','c'};
char arr2[3] = {'a',98,'c'}//与上一个是一样的，因为b的ASCLL码值是’98‘

我们发现不指定数组大小创建arr1时，因为是字符串所以数组中会多存一个‘/0’

1.3 一维数组的使用

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

#include <stdio.h>
int main()
{
 int arr[10] = {0};//数组的不完全初始化
    //计算数组的元素个数
    int sz = sizeof(arr)/sizeof(arr[0]);
 //对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：
 int i = 0;//做下标
 for(i=0; i<10; i++)//这里写10，好不好？
 {
 arr[i] = i;
 } 
 //输出数组的内容
 for(i=0; i<10; ++i)
 {
 printf("%d ", arr[i]);
 }
 return 0;
}

总结:

1. 数组是使用下标来访问的，下标是从0开始。

2. 数组的大小可以通过计算得到。

int arr[10];
int sz = sizeof(arr)/sizeof(arr[0]);
printf("%d", sizeof(arr));//40
printf("%d", sizeof(arr[0]));//4

 

sizeof(数组名) ：表示包含了整个数组，计算的是整个数组的大小

 sizeof(具体数组下标)：表示数组内的单个元素，计算的是单个数组内部元素的大小

这里再补充一点关于数组名改怎么理解

数组名通常情况下就是数组首元素地址。

但是有两个例外

1. sizeof(数组名)，数组名单独放在sizeof()内部，这里的数组名表示整个数组，计算的是整个数组的大小
2. &数组名，这里的数组名也表示整个数组，这里取出的是整个数组的地址

除此之外所有遇到的数组名都表示数组首元素地址

来看代码

int main()
{
	int arr[5] = { 1,2,3,4,5 };
	printf("%p\n", arr);//数组首元素地址
	printf("%p\n", arr+1);//数组第二元素地址

	printf("%p\n", &arr[0]); //数组首元素地址
	printf("%p\n", &arr[0]+1);//数组第二元素地址

	printf("%p\n", &arr);//数组的地址=数组首元素地址
	printf("%p\n", &arr+1);//以整个数组为单位加一个单位（20）

	return 0;
}

00000015142FFCE8
00000015142FFCEC 地址位相差4

00000015142FFCE8
00000015142FFCEC  地址位相差4

00000015142FFCE8
00000015142FFCFC  地址位相差20

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

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

看代码：

#include <stdio.h>
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;
}

可以发现他们的地址（十六进制）都差了4（字节），每相邻两个元素都差了4，因为每一个元素存放的是整形，而整形所占地址就是4

随着数组下标的增长，元素的地址，也在有规律的递增。

由此可以得出结论：数组在内存中是连续存放的。

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

2.1 二维数组的创建

//数组创建
int arr1[3][4];
char arr2[3][5];
double arr3[2][4];

第一个括号内的数字代表行，第二个括号内的数字代表列。

我们画图表示

arr1[3][4]表示创建了3行4列的二维数组，中间的空行来存储元素

我们再来看看在内存如何存放

arr1和arr2创建了3行，而arr3创建了2行

2.2 二维数组的初始化

//数组初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};//二维数组如果有初始化，行可以省略，列不能省略

注意：二维数组如果有初始化，行可以省略，列不能省略

2.3 二维数组的使用

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

看代码：

int main()
{
	int arr[4][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7},{4,5,6,7,8} };
	printf("%d", arr[1][4]);

	return 0;
}

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

输出的结果是这样的：

&arr[0][0] = 00000007CC2FF568
&arr[0][1] = 00000007CC2FF56C
&arr[0][2] = 00000007CC2FF570
&arr[0][3] = 00000007CC2FF574
&arr[1][0] = 00000007CC2FF578
&arr[1][1] = 00000007CC2FF57C
&arr[1][2] = 00000007CC2FF580
&arr[1][3] = 00000007CC2FF584
&arr[2][0] = 00000007CC2FF588
&arr[2][1] = 00000007CC2FF58C
&arr[2][2] = 00000007CC2FF590
&arr[2][3] = 00000007CC2FF594

 

通过结果我们可以分析到，（十六进制）每个元素相差4（字节）的地址，其实二维数组在内存中也是连续存储的。

我们再来将他们初始化查看存放的方法，我们将数组初始化，然后按照数组下标将他们每一位打印出来。

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

arr[0][0] = 1 arr[0][1] = 2 arr[0][2] = 3 arr[0][3] = 4 arr[0][4] = 5

arr[1][0] = 2 arr[1][1] = 3 arr[1][2] = 4 arr[1][3] = 5 arr[1][4] = 6

arr[2][0] = 3 arr[2][1] = 4 arr[2][2] = 5 arr[2][3] = 6 arr[2][4] = 7

arr[3][0] = 4 arr[3][1] = 5 arr[3][2] = 6 arr[3][3] = 7 arr[3][4] = 8

我们可以把每种颜色区分为不同的一维数组

而这些一维数组中又存放着5个元素

所以可以发现：二维数组其实是一维数组的数组，意思就是存放一维数组的数组。

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

二维数组的行和列也可能存在越界。

4. 数组作为函数参数

往往我们在写代码的时候，会将数组作为参数传个函数，比如：我要实现一个冒泡排序（这里要讲算法 思想）函数

将一个整形数组排序。

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

#define a 5
void bubble(int* arr, int sz)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < sz - 1; i++)
	{
		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[a] = { 0 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < a; i++)
	{
		scanf("%d", &arr[i]);
	}
	bubble(arr,sz);
	for (i = 0; i < a; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}