目录
一、一维数组的创建和初始化
1.数组的创建
（1）基本定义，创建方式
（2）经典的错误标准的零分
2.数组的初始化
3.一维数组的使用
4.一维数组在内存中的存储
二、二维数组的创建和初始化
1.二维数组的创建
2.二维数组的初始化
3.二维数组的使用
4.二维数组在内存中的存储
三、数组越界
四、数组作为函数参数
1.关于冒泡排序的经典错误标准零分
2.数组名到底是什么呢
（1）一般的，数组名是首元素地址
（2）数组不是首元素地址的两个特例
第一个特例，sizeof（数组名）
第二个特例，&数组名
（3）总结
（4)&数组名和直接使用数组名的区别
3.再次研究冒泡排序
总结
一、一维数组的创建和初始化
1.数组的创建
（1）基本定义，创建方式
定义：数组是一组相同类型元素的集合。
数组的创建方式：type_t arr_name [const_n];
//type_t 是指数组的元素类型//const_n 是一个常量表达式，用来指定数组的大小举例：int arr1[10];char arr2[5+6];double arr3[10];
（2）经典的错误标准的零分
如下代码所示，不满足常量表达式，因为n是一个变量。
#include<stdio.h>
int main()
{
int n = 10;
int arr[n];
return 0;
}2.数组的初始化
下面是数组的初始化的各种方式以及区别
这是整型数组
#include<stdio.h>
int main()
{
//创建的同时给数组一些值，这叫初始化
int arr[10] = {1,2,3,4,5,6,7,8,9,10};//完全初始化
int arr2[10] = { 1,2,3 };//不完全初始化，剩余的元素默认初始化为0
int arr3[] = { 1,2,3,4,5,6,7,8,9,10 };//这里没有指定数组元素个数，编译会根据初始化的内容来确定数组的元素个数
int arr4[] = { 1,2,3 };//3个元素
int arr5[10] = { 1,2,3 };//10个元素
}这是字符数组
#include<stdio.h>
int main()
{
//arr6与arr7一模一样都是有3个元素，并且为a，b，c
char arr6[3] = { 'a', 'b', 'c' };
char arr7[] = { 'a', 'b', 'c' };
char arr8[10] = "abc";//十个元素，前三个为abc,后面都为\0
char arr9[] = "abc";//四个元素，前三个为abc，最后一个为\0
}还有一种就是全局数组不初始化默认为0，局部数组不初始化为随机值，这一点与全局变量不初始化默认为0，局部变量不初始化为随机值是类似的。
下面是调用监视窗口查看全局数组a1和局部数组a的内容。
还有这两个初始化一定要搞清楚他们的区别
#include<stdio.h>
int main()
{
char arr8[] = "abc";
char arr9[] = {'a', 'b', 'c'};
printf("%s\n", arr8);
printf("%s\n", arr9);
}arr8中有\0，arr9没有\0
运行结果为
3.一维数组的使用
在之前我们提到过一个下标引用操作符 [ ],他其实就是数组访问的操作符。
1.数组都是由下标的，下标是从0开始的
2.[]下标引用操作符
下面是顺序打印数组的方法
#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("%d ", arr[i]);
}
return 0;
}下面是倒序打印数组，跳着打印数组
#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("%d ", arr[i]);
}
printf("\n");
for (i = sz-1; i >=0; i--)
{
printf("%d ", arr[i]);
}
printf("\n");
for (i = 0; i < sz; i=i+2)
{
printf("%d ", arr[i]);
}
return 0;
}4.一维数组在内存中的存储
#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;
}结果为
1.一维数组在内存中是连续存放的2.随着数组下标的增长，地址是由低到高变化的
#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]);
int* p = &arr[0];
for (i = 0 ; i < sz; i++)
{
printf("arr[%d]=%d\n", i, *(p+i));
}
return 0;
}运行结果为
我们也可以试一下这个代码，验证一下指针+i的地址与&arr[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]);
int* p = &arr[0];
for (i = 0 ; i < sz; i++)
{
printf("%p -----%p\n", p+i, &arr[i]);
}
return 0;
}运行结果为
可见两个地址是一样的
二、二维数组的创建和初始化
1.二维数组的创建
int arr[3][4];char arr[3][5];double arr[2][4];
2.二维数组的初始化
#include<stdio.h>
int main()
{
int arr[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
return 0;
}我们调试进行监视， 可以得到他们的分布
我们再试试没有放满的
#include<stdio.h>
int main()
{
int arr1[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
int arr2[3][4] = { 1,2,3,4,5 };
return 0;
}
我们在换一种初始化方式
#include<stdio.h>
int main()
{
int arr1[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
int arr2[3][4] = { 1,2,3,4,5 };
int arr3[3][4] = { {1,2} ,{3,4}, {5,6} };
return 0;
}
3.二维数组的使用
#include<stdio.h>
int main()
{
int arr1[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
int arr2[3][4] = { 1,2,3,4,5 };
int arr3[3][4] = { {1,2} ,{3,4}, {5,6} };
int arr4[][2] = { 1,2,3,4,5,6,7,8,9 };
int i = 0;
for (i = 0; i < 5; i++)
{
int j = 0;
for (j = 0; j < 2; j++)
{
printf("%d ", arr4[i][j]);
}
printf("\n");
}
return 0;
}4.二维数组在内存中的存储
#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 < 4; j++)
{
printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
}
}
return 0;
}
结果为
我们会发现，还是每个元素差四个字节
也就是说二维数组也是和一维数组一样线性连续存储的！如下图所示，前四个为第一行，中间为第二行，后面为第三行，我们可以把一个二维数组当成一个一维数组来理解
那我们二维数组也就可以使用一维数组那样采用指针的方式来打印
#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 < 4; j++)
{
printf("%d ", arr[i][j]);
}
}
printf("\n");
int* p = &arr[0][0];
for (i = 0; i < 12; i++)
{
printf("%d ", *(p + i));
}
return 0;
}
输出结果为
而且我们二维数组每一行都可以理解为一个一维数组，这个一维数组的数组名为arr[0],arr[1]......如下图所示
所以二维数组也是一维数组的数组
所以我们的打印数组也可以这样进行
#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 < sizeof(arr)/sizeof(arr[0]); i++)
{
int j = 0;
for (j = 0; j < sizeof(arr[0])/sizeof(arr[0][0]); j++)
{
printf("%d ", arr[i][j]);
}
}
} 
三、数组越界
数组的下标是有范围限制的。数组的下规定是从 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;
}运行结果为，其中就出现了一个明显的错误。
二维数组的行和列也可能存在越界。
四、数组作为函数参数
往往我们在写代码的时候，会将数组作为参数传个函数，比如说我们想写出一个冒泡排序。
1.关于冒泡排序的经典错误标准零分
那么什么是冒泡排序呢？
比如说我们想要对下面一组数据进行升序的话
我们是这样想的，我们让9和8进行比较，如果9大于8，那么9和8进行交换，然后交换以后变成以下
此时我们让第二个和第三个位置数据继续进行比较，并进行交换。然后重复下去，直到最后会变成
我们发现9已经来到了他应该来到的最终位置，那么我们前面八个数还需要进行排序。我们继续采用相同的方法。我们会发现，前八个数字最终也会
此时我们发现8也来到了他应该来到的最终位置.
不妨我们就将这称作一趟冒泡排序，每一趟冒泡排序都可以使得一个数放到他应该来到的最终位置
那么问题来了，如果有10个数字，那么需要多少趟？
显然为9趟，对于任意n个数字，只需n-1趟冒泡排序。
于是我们就有冒泡排序的一个基本框架了
这里的for循环可以确定需要多少趟冒泡排序，而里面每一层都是一趟冒泡排序
那么一趟需要比较多少次呢？
我们回顾前面的那个案例，不难发现，第一趟，需要9次比较，第二趟需要8次比较，我们总结规律，n个元素需要n-i-1次比较。
由此得到代码实现如下所示
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void sort(int arr[])
{
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (int j = 0; j < sz - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int tmp = 0;
tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}
int main()
{
int arr[] = { 4,5,1,3,7,10,100,45,323,852};
sort(arr);
for (i = 0; i < 10; i++)
{
printf("%d\n", arr[i]);
}
return 0;
}然而当我们进行运行的时候,我们发现结果并非我们所期望的
并没有进行交换，这是为什么呢？其实问题就出在了sizeof，我们数组的传参传的其实是一个指针，而非整个数组，所以sizeof（arr）计算出来的并不是一个数组的长度，而是arr这个指针的大小，所以我们就应该将sz给放到主函数中，然后在传参的时候传入sz
代码实现如下
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void sort(int arr[],int sz)
{
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (int j = 0; j < sz - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int tmp = 0;
tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}
int main()
{
int arr[] = { 4,5,1,3,7,10,100,45,323,852};
int sz = sizeof(arr) / sizeof(arr[0]);
sort(arr,sz);
int i;
for (i = 0; i < sz; i++)
{
printf("%d\n", arr[i]);
}
return 0;
}运行后结果为
可见符合我们的预期
2.数组名到底是什么呢
我们在冒泡排序中，数组名一会是指针，一会代表整个数组，一会代表首元素地址。相信到了这块很多人都晕了，数组名到底是什么呢？
（1）一般的，数组名是首元素地址
一般情况下数组名是首元素地址，那么很多人就更加困惑了，什么是非一般情况呢？先不要着急，我们先来看看数组名是首元素地址的案例
int main()
{
int arr[10] = { 0 };
printf("%p\n", &arr[0]);
printf("%p\n", arr);
return 0;
}运行之后
（2）数组不是首元素地址的两个特例
第一个特例，sizeof（数组名）
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%d", sizeof(arr));
return 0;
}运行结果为
其实，sizeof（数组名），这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节
第二个特例，&数组名
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%p\n", &arr[0]);
printf("%p\n", arr);
printf("%d\n", sizeof(arr));
printf("%p\n", &arr);
return 0;
}运行结果为
可见这里的数组名表示的是整个数组，&数组名取出的是数组的地址
（3）总结
一般情况下，数组名是首元素的地址，但有两个例外，一个是sizeof（数组名），一个是&数组名，这两种情况下，数组名代表的是整个数组。
（4)&数组名和直接使用数组名的区别
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%p\n", &arr[0]);
printf("%p\n", &arr[0]+1);
printf("%p\n", arr);
printf("%p\n", arr+1);
printf("%p\n", &arr);
printf("%p\n", &arr+1);
return 0;
}运行后结果为
可见，第一组+1后的地址是+4，第二组+1后的地址也是+4，而第三组+1后的地址是加了40
我们发现，虽然结果一样，也就是他们的起点一样，但是他们的含义不同，&arr+1是直接跳过整个数组，而前两者仅仅跳过一个元素。
3.再次研究冒泡排序
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void sort(int arr[],int sz)
{
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (int j = 0; j < sz - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int tmp = 0;
tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}
int main()
{
int arr[] = { 4,5,1,3,7,10,100,45,323,852};
int sz = sizeof(arr) / sizeof(arr[0]);
sort(arr,sz);
int i;
for (i = 0; i < sz; i++)
{
printf("%d\n", arr[i]);
}
return 0;
}我们现在应该能够理解了这段代码中，为什么sz要放在主函数内部了，虽然我传的是一个数组名，但是此时的数组名代表着首元素地址，而我们的形参虽然人模狗样的写着一个数组，但是其实他本质上是一个指针。也就说我们可以将他改为一个指针变量。
我们可以将其改为指针试一试
void sort(int* arr, int sz)
{
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (int j = 0; j < sz - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int tmp = 0;
tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}我们运行后，这个代码仍然是正确的，所以我们传数组可以使用一个指针来接受。当然我们也可以使用一个数组的形式来进行接受，这样其实更加便于初学者理解。
而我们传入一个指针以后，我们就可以对这个指针进行+1，而整型指针+1，向后移动4个字节。刚好就是下一个数据。所以采用指针可以顺藤摸瓜，拿到整个数组的值。
当然有人就有一些困惑了，为什么我们平时函数传参的时候是直接拷贝过去，而数组却是传地址呢？这一点大家可以思考以下，如果我有10000个元素的数组，那么我们还要传整个数组的话，那么对这对于计算机内存上，运行速度上都会产生极大的浪费。所以使用指针传参也是很合理的。
总结
本节主要讲解了数组的一些基本知识点，基本概念，以及数组传参时候的一些坑，如果对你有一些帮助的话，不要忘记点赞加收藏哦！！!
