一.一维数组
数组是一组相同类型元素的集合。
数组的创建方式：
type_t ?arr_name ?[const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小
数组创建的实例：
//代码1
int arr1[10];
//代码2
int count = 10;
int arr2[count];//C99开始可以这样实使用
//代码3
char arr3[10];
float arr4[1];
double arr5[20];
1.数组是使用下标来访问的，下标是从0开始。
2. 数组的大小可以通过计算得到。?
int arr[10];
int sz = sizeof(arr)/sizeof(arr[0]);
?仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。
由此可以得出结论：数组在内存中是连续存放的。
二.二维数组
通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。
由以上列子可知，数组名即是数组首元素的地址?
以上代码可说明，因为数组在内存中连续存放，所以用指针的写法和用数组打印出来的结果一样。
以上代码也可以说明二维数组是连续存储的。?
数组越界：
数组的下标是有范围限制的。
数组的下规定是从0开始的，如果输入有n个元素，最后一个元素的下标就是n-1。
所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以程序员写代码时，最好自己做越界的检查。
如以下代码所示：
?正确的写法应该是：
二维数组的行和列也可能存在越界。
结论： 数组名是数组首元素的地址（有两个例外）
1.sizeof（数组名），这里的数组名表示整个数组，sizeof（数组名）计算的是整个数组的大小。
2.&数组名，这里的数组名表示整个数组，取出的是数组的地址
数组作为函数参数：
往往我们在写代码的时候，会将数组作为参数传个函数，比如：我要实现一个冒泡排序
首先什么是冒泡排序？
核心思想：两两相邻的元素进行比较?
一趟冒泡排序可以搞定一个数字，让它来到最终应该出现的位置上。
?
源代码：
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//int arr[5];//全局变量不初始化存放的都是0
//int main()
//{
//?? ?int arr1[20] = { 1,2,3 };//不完全初始化，剩余的默认初始化为0
//?? ?int arr2[] = { 1,2,3 };//只存放三个元素
//?? ?char arr3[] = "abc";//数组存放了abc\0这四个字节
//?? ?char arr4[] = { 'a','b','c' };//只存放abc三个元素
//?? ?char arr5[] = { 'a',98,'c' };//98是b的ASCLL码值
//?? ?int arr6[5];//局部变量不初始化存放的都是随机值
//?? ?return 0;
//}
//int main()
//{
//?? ?int arr[10] = { 0 };
//?? ?int i = 0;
//?? ?for (i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
//?? ?{
//?? ??? ?printf("&arr[%d] = %p\n", i, &arr[i]);
//?? ?}
//?? ?return 0;
//}
数组创建
//int main()
//{
//?? ?int arr[3][4];//三行四列的表格
//?? ?char arr[3][5];
//?? ?double arr[2][4];
//?? ?return 0;
//}
//int main()
//{
//?? ?//数组初始化
//?? ?int arr[3][4] = { 1,2,3,4 };//一行一行放满再会到下一行
//?? ?int arr[3][4] = { {1,2},{4,5} ,{6,7} };//第一行放的是12000，第二行是34000，第三行是67000
//?? ?int arr[][4] = { {2,3},{4,5} };//二维数组初始化时可以省略行，不可省略列
//
//?? ?char ch[4][6] = { 'a','b' };//第一行依次放的是a，b
//?? ?char ch[4][6] = { {'a'},{'b'} };//第一行和第二行分别放a和b
//?? ?char ch[4][6] = { "abc","def","qwe" };//三行分别为abc\0，def\0，qwe\0
//?? ?return 0;
//}
//
//int main()
//{
//?? ?int arr[3][5] = { {1,2,3},{4,5},{6,7,8,9,0} };
//?? ?int i = 0;
//
//?? ?for (i = 0; i < 3; i++)
//?? ?{
//?? ??? ?int j = 0;
//?? ??? ?for (j = 0; j < 5; j++)
//?? ??? ?{
//?? ??? ??? ?printf("&arr[%d][%d]%p\n ",i,j, &arr[i][j]);
//?? ??? ?}
//?? ??? ?printf("\n");
//?? ?}
//?? ?return 0;
//}
//
//int main()
//{
//?? ?int arr[5] = { 1,2,3,4,5 };
//?? ?printf("%p\n", arr);
//?? ?printf("%p\n", &arr[0]);
//?? ?return 0;
//}
//int main()
//{
//?? ?int arr[5] = { 1,2,3,4,5 };
//?? ?int *p = arr;
//?? ?int i = 0;
//?? ?for (i = 0; i < 5; i++)
//?? ?{
//?? ??? ?printf("%d ", *p);
//?? ??? ?p++;
//?? ?}
//?? ?printf("\n");
//?? ?for (i = 0; i < 5; i++)
//?? ?{
//?? ??? ?printf("%d ", arr[i]);
//?? ?}
//
//?? ?return 0;
//}
//
//int main()
//{
//?? ?int arr[3][5] = { {1,2,3},{4,5},{6,7,8,9,0} };
//?? ?int*p = &arr[0][0];
//?? ?int i = 0;
//?? ?for (i = 0; i < 15; i++)
//?? ?{
//?? ??? ?printf("%d ", *p);
//?? ??? ?p++;
//?? ?}
//?? ??? ?return 0;
//}
//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;
//}
//int main()
//{
//?? ?int arr[10] = { 1,2,3,4,5 };
//?? ?printf("%p\n", arr);
//?? ?printf("%p\n", &arr[0]);
//?? ?printf("%d\n", *arr);
//?? ?//输出结果
//?? ?return 0;
//}
//int main()
//{
//?? ?int arr[10] = { 1,2,3,4,5 };
//?? ?printf("%p\n", arr);//数组首元素的地址
//?? ?printf("%p\n", &arr[0]);//数组首元素的地址
//?? ?printf("%p\n", &arr);//数组的地址
//?? ?printf("-----------------\n");
//?? ?printf("%p\n", arr+1);
//?? ?printf("%p\n", &arr[0]+1);
//?? ?printf("%p\n", &arr+1);//指向数组的指针会跳一整个数组
//
//?? ?return 0;
//}
冒泡排序
//void Sort(int arr[],int sz)//数组传参实际上传过去的是数组首元素的地址
//{
//?? ?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这一步需要好好思考
//?? ??? ?{
//?? ??? ??? ?if (arr[j] > arr[j + 1])
//?? ??? ??? ?{
//?? ??? ??? ??? ?//交换
//?? ??? ??? ??? ?int tmp = arr[j];
//?? ??? ??? ??? ?arr[j] = arr[j + 1];
//?? ??? ??? ??? ?arr[j + 1] = tmp;
//?? ??? ??? ?}
//?? ??? ?}
//?? ?}
//}
//int main()
//{
//?? ?int arr[] = { 1,4,2,3,8,7,5,6,9,0 };
//?? ?//数组传参
//?? ?//排序
//?? ?int sz = sizeof(arr) / sizeof(arr[0]);//数组名单独放在sizeof内部时，如：sizeof(arr),这里的arr表示的是整个数组，而不是首元素地址
//?? ?Sort(arr,sz);//数组名在传递给函数的时候，会降级变成首元素的地址
//?? ?for (int i = 0; i < sz; i++)
//?? ?{
//?? ??? ?printf("%d ", arr[i]);
//?? ?}
//?? ?return 0;
//}