一些你万一不知道的数组知识和小细节

本人能力有限，难免有叙述错误或者不详细之处！希望读者在阅读时可以反馈一下错误以及不够好的地方！感激不尽！

目录

一维数组的创建及其初始化

数组的创建:

数组的初始化：

 一些细节：

数组元素的计数：

二维数组

二维数组的创建：

数组越界

冒泡排序与数组的传参

啥是冒泡排序？

数组的传参：

数组名到底是什么？

指针数组

---

在C语言中，数组本身的概念并不复杂，但是其本身有一些细节方面的概念仍然需要被注意一下，以下则是对数组这个玩意儿的概述以及一些细节方面的记录。

一维数组的创建及其初始化

数组的创建:

一维数组的创建和普通变量在声明的时候是一样的，需要声明数组的变量类型。

int arr1[10]
char arr2[10]
float arr3[10]

变量类型后的arr1是数组名称，在【】内的常量则可以指定这个数组大小。（于一些编辑器下【】内对数组大小的指定是可以使用变量的，比如arr【n】）

【】其实是下标引用 *** 作符

当然，【】里面也可以不指定数组的大小，让其自适应大小，编译器还是挺聪明的，它会自主的生成对应大小的空间存放其中的元素

	int main()
	{
		int arr[] = { 1,2,3,4,5 };
		printf("%d", sizeof(arr));
		return 0;
	}

 

我们可以看到，就算没有指定数组的大小，编译器依然正确的为数组分配了空间。

如同垃圾分类一样，在声明完毕变量类型之后，数组内的元素类型应该与数组类型相同，比如当我们创建一个char类型的数组时，存放的元素应该是字符串。

char arr[] = "hello hello";

数组的初始化：

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

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

当数组不完全初始化时，其余的元素空位会被填充上0

int i = 0;
int arr[5] = {1,2,3};
for (i = 0; i < 5 ; i++)
{
    printf ("%d ",arr[i]);
}

而需要注意的是，数组的计数从0开始，当我们想取出数组内某一个元素的值的时候，我们应该时刻注意数组的下标。

---

---

 一些细节：

字符串在内存中的存储是如下图所示的：

比如char arr[] = "hello";

 在字符串的末尾，是一个\0

程序在存储字符串的时候，由于是在内存中开辟空间，所以需要知道这串字符串到底在哪结束，而\0就是程序知道字符串结束的标志。

所以有一个问题，当我们刻意的去避开\0的时候会发生什么？

借由数组我们可以尝试实现一下：

	int main()
	{
		int i = 0;
		char arr[] = { 'h','e','l','l','o'};
	
		printf("%s ", arr);		

		return 0;
	}

 

 出现了！手持两把锟斤拷，口中疾呼烫烫烫

很明显，由于我们刻意的初始化数组，程序访问字符串时不知道什么时候停手了，从而访问过头得到了乱码。

---

数组元素的计数：

有时候，我们会需要数组的元素个数，我们可以借由如下的方法计算得到而不用去一个个的数，但是需要注意char类型数组在存放字符串的时候数组的大小会有所不同

int main()
{
	int arr[10];
	char arr1[] = "one";

	int sz = sizeof(arr) / sizeof(arr[0]);//数组整体的大小除以其元素大小得到其元素个数
	int sz2 = sizeof(arr1) / sizeof(arr1[0]);

	printf("%d ", sz);
	printf("%d ", sz2);

	return 0;
}

 我们可以看到，arr1里面只放入了3个字符却输出了4，其实原因是sizeof在计算字符串数组大小的时候也会把\0算进去，所以输出了4。

二维数组

二维数组的创建：

int arr[3][4];
char arr[3][5];
double arr[2][4];

二维数组相较于一维数组是有一定差别的，其中最大的莫过于初始化的时候：

int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};//行可以省略，列不能省略！

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

二维数组的打印与存储：

 arr[3][4]指的是该二维数组有3行，每行的元素有4个。

只需初始化部分元素的时候可以使用{}分隔开

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

 

 这样子的初始化是错误的

---

数组越界

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

冒泡排序与数组的传参

在冒泡排序中我们需要传递数组的元素个数，这并不困难，使用上文的sz的计算方法即可。

在此之前，先介绍冒泡排序。

啥是冒泡排序？

有一个乱序的数组，我们想将其正序排序并打印出来就可以使用冒泡排序，冒泡排序原理如下图：

我们可以发现，冒泡排序就会像一个气泡不断上浮一样一个个把最大的数字向后排，每一次大循环都能保证最大的数字排在最后一位直到完成排序，这就是冒泡排序的基本逻辑。

我们可以借由逻辑写出以下代码：

#include 
void bubble(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(arr);
	int i = 0;
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

失败了！为什么我们的bubble函数没有做它应该做的事呢？这年头难道函数都能摸鱼的吗？

其实并不是，主要问题其实出在数组传参的时候的一些规则问题。

数组的传参：

经过逐语句调试，发现了问题所在：

 sz的值并没有获得整个数组元素的个数，而是获得了一个1，这是为什么？

原因其实是数组在传参的时候，传递的是：首元素的地址

所以我们整这里看上去好像传递过去的是一整个数组，但其实传过去的只是个指针

（灵魂画手上线）

 

 

 

 于是，冒泡函数根本不知道整个数组有多少个元素，算不出来了。

正确代码如下，有两种形式，但都应该现在主函数内部先把sz的值算好传进去才行：

形参是数组：

void bubble(int arr[], int sz)
{
	int i = 0;
	int tmp = 0;
	int n = 0;

	for (i = 0; i < sz - 1; i++)
	{
		for (n = 0; n < sz - i - 1; n++)
		{
			if (arr[n] > arr[n + 1])
			{
				tmp = arr[n];
				arr[n] = arr[n + 1];
				arr[n + 1] = tmp;
			}

		}
	}
}

int main()
{
	int arr[] = { 6,8,7,5,4,3,2,1 };
	int n = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);


	bubble(arr, sz);
	for (n = 0; n < sz; n++)
	{
		printf("%d ", arr[n]);
	}
	return 0;
}

形参是指针：

void bubble(int* arr,int sz)
{
	//趟数
	int i = 0;
	for (i = 0; i < sz-1; i++)
	{
		//一趟冒泡排序
		int j = 0;
		for (j=0; j arr[j + 1])
			{
				//交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

 至此，我们可能有个小疑问，那这个数组名到底是个什么玩意？

数组名到底是什么？

我们使用以下代码来看看：

int arr[10] = {1,2,3,4,5};
printf("%p\n", arr);
printf("%p\n", &arr[0]);
printf("%d\n", *arr);

 结论：数组名就是首元素的地址。

但是！有两个例外！

当我们把数组名放进sizeof里头的时候：

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

 

 sizeof输出了整个数组的大小，这是一个例外，也就是当数组名放入sizeof时，sizeof会将数组名视作整个数组并求出它的大小。

另一个例外则是： &数组名，取出的是数组的地址。&数组名，数组名表示整个数组

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

指针数组

存放指针的数组就是指针数组

创建：int * parr【10】= {&a,&b,&c};

由于属于概述，不做过多细述，不过以下则细述了如何利用指针数组实现二维数组的效果：

我想用指针数组实现二维数组的打印效果

我先创建3个一维数组：

int arr1[4] ={1,2,3,4}

int arr2[4] ={1,2,3,4}

int arr3[4] ={1,2,3,4}

然后我创建一个指针数组来存放这3个数组。

int * parr[3]={arr1,arr2,arr3};

int i = 0;

for (i = 0;i < 3;i++)

{

int j = 0;

for (j = 0; j < 4; j ++)

{

我希望直接借由这个行列打印直接打印二维数组，那么我要借用这些计数变量来实现。

printf("%d",parr[i][j])明明不是一个二维数组，怎么就可以成功的打印两行呢？

parr[i]这个指针数组，在访问其中的元素的时候，获取的是其中数组的首地址，相当于parr【1】==arr1,我们将parr[i][j]转换过来一看不就是arr1[j]吗？j每次自增1，依次打印其中的元素，这样就可以成功的实现二维数组的效果了！

}

printf（"\n")；不要忘记换行！

}

感谢阅读！希望对你有点帮助！