C语言中的数组

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

1.1、数组的创建
数组是一组相同类型元素的集合。
数组的创建方式：

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

	char arr1[20];//
	float arr2[10];
	double arr3[10];

int count = 10;
int arr2[count];
不能这样创建！！！！
注：数组创建， [] 中要给一个常量才可以，不能使用变量

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

数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。
下面 [ ] 没有给确定的值，就说明数组的大小就看{ }中元素个数有多少个，那数组的大小就是多少

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

char arr1[] = "abc";
char arr2[3] = {'a','b','c'};

我们看到arr1中包含了 \0 ,而arr2中没有包含 \0

注意：
int arr1[10]= {1, 2，3};元素个数有10个，所以后面默认补0；

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

#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9 };//数组初始化
	int sz = sizeof(arr) / sizeof(arr[0]) - 1;//计算数组的大小
	int i = 0;
	for (i = 0; i <= sz; i++)
	{
		printf("%d  ", arr[i]);//打印数组中每一个元素
	}
	return 0;
}

总结:

1. 数组是使用下标来访问的，下标是从0开始。
2. 数组的大小可以通过计算得到

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

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

仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。
由此可以得出结论：数组在内存中是连续存放的

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

2.2、二维数组的初始化

注意：int arr【】【4】第一个括号中的数字可以省略，第二个括号中的数字不可以省略。

2.3 二维数组的使用
看代码：

#include<stdio.h>
int main()
{
	int arr[3][4] = { {1,2,3},{7},{9,10} };
	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;
}

2.4 二维数组在内存中的存储
像一维数组一样，这里我们尝试打印二维数组的每个元素

#include<stdio.h>
int main()
{
	int arr[3][4] = { {1,2,3},{7},{9,10} };
	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;
}

通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。

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

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

#include<stdio.h>

void maop(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i <= sz - 1; i++)//两个数字比较 
	{
		int flag = 0;
		int j = 0;
		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 i = 0;
	int arr[] = { 5,4,6,2,1,3,8,9,7 };
	int sz = sizeof(arr) / sizeof(arr[0]) - 1;
	printf("排序前：");
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	printf("--------------------------\n");
	maop(arr, sz);
	printf("排序后：");
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

4.2 数组名是什么？

结论：
数组名是数组首元素的地址
有两个例外：
1. sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数
组。
2. &数组名，取出的是数组的地址。&数组名，数组名表示整个数组

有关于数组的内容希望大家补充。