【C语言】数组讲解
- 1.一维数组的创建和初始化
- 1.1一维数组的创建
- 1.2一维数组的初始化
- 1.3一维数组的使用
- 1.4一维数组在内存中的存储
- 2.二维数组的创建和初始化
- 2.1二维数组的创建
- 2.2二维数组的初始化
- 2.3二维数组的使用
- 2.4一维数组在内存中的存储
- 3.数组越界
- 4.数组作为函数参数
- 4.1冒泡排序的错误设计
- 4.2数组名是什么
- 4.3冒泡排序函数的正确设计
所属专栏：C语言
博主首页：初阳785
代码托管：chuyang785
感谢大家的支持，您的点赞和关注是对我最大的支持！！！
博主也会更加的努力，创作出更优质的博文！！
关注我，关注我，关注我，重要的事情说三遍！！！！！！！！
1.一维数组的创建和初始化
我们之前讲过了很多的类型，比如我们的int，char，double，float，long等等。
而当我们常见一个变量的时候，都是只能通过一个类型创建一个与之对应的变量。
但是问题就来了，如果我们想要创建一连串相同类型的变量该怎么办呢？难道还是一个一个的创建吗？如果是这样的话不仅会浪费我们的时间，还会是我们写的代码累赘在一起。
这个时候就有了数组的概念。
数组是一组形同类型的集合。
1.1一维数组的创建
数组的创建方式：
type_t arr_name [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小
这里我们 [ const_n] const_n不一定要是常量表达式，也可以是变量，但是得看我们的C标准。
数组创建，在C99标准之前， [] 中要给一个常量才可以，不能使用变量。在C99标准支持了变长数组的概念，数组的大小可以使用变量指定，但是数组不能初始化。
数组创建的实例：
//代码1
int arr1[10];
//代码2
int count = 10;
int arr2[count];//数组时候可以正常创建？
//这种写法我们一般认为是错误的，但是在其他的语言或者C标准是支持这样写的。
//代码3
char arr3[10];
float arr4[1];
double arr5[20];
1.2一维数组的初始化
数组的初始化是指在创建数组的同时给数组内容一些合理的初始值（初始化）。
初始化方式：
type_t arr_name [const_n]={num1,num2,……，mum(const_n)};
我们初始化的时候初始值使用一对{}括起来的，而我们的元素个数就是const_n个。
注释：
我们的字符串数组创建的时候也可以不用{}括起来，是可以用 " "包含的：
char arr[3]="abc";
我们看一下以下创建数组的方式：
int arr1[10] = {1,2,3};
int arr2[] = {1,2,3,4};
int arr3[5] = {1，2，3，4，5}；
char arr4[3] = {'a',98, 'c'};
char arr5[] = {'a','b','c'};
char arr6[] = "abcdef";//对字符串特殊的定义数组方式。
在上面我们看到有些数组并没有给定数组的大小的，而是直接初始化值的。
这里说明一下： == 数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定的==。也就是说，你不给定数组的大小，但是你给定了数组初始值，这个时候我们的编译器会自动计算数组的大小的。
如果我们定义一个数组：int arr[10]={1，2，3};这个叫做数组的不完全初始化，顾名思义就是我们初始化的个数不等于我们的给定数组的大小。
不完全初始化的时候如果我们后期不给数组赋值的话编译器默认是初始化为0的。
这里我们们针对字符串数组来系统的讲解一下：
上面我们讲了字符串数组可以：char arr6[] = “abcdef”;这样字定义。
我们从表面上看过去这个数组的大小是6，但是其实他的大小是7，因为在我们的字符串后面隐藏了一个字符 \0 但是这个字符是不被计算道数组大小里面的所以数组的大小是6.
这里我们可以看到有个\0，而这个\0是作为字符串的结束标志的。
1.3一维数组的使用
对于数组的使用我们之前介绍了一个操作符： [] ，下标引用操作符。它其实就数组访问的操作符。
在使用之前我们先了解一下我们数组的下标，在我们的编程中我们的数组下标默认是从0开始的。
我们来看代码：
#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++)
{
arr[i] = i;
}
//输出数组的内容
for (i = 0; i < 10; ++i)
{
printf("%d ", arr[i]);
}
return 0;
}
这里我们就需要了解一下怎么计算素组的大小，前面我们也提到过了计算素组大小的关键字sizeof（），sizeof（arr）计算的整个素组元素的字节大小，而我们的sizeof(arr[0]）是计算一个元素的字节大小，这样总的字节大小/每个元素的字节大小，就得到了元素个数。
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;
}
这里我们补充一个知识点：%p是用来打印地址的
这个是他们的打印结果。
我们试着画出他们的内存分布：
注释：这里与由于地址过长，我们统一先取出后4为作为对比。
我们假设0xF748是我们的开始地址，依次往后对我们的地址增加0xF748后一位地址就是0xF749这个时候我们对比一下第一个元素和第二个元素以及我们的第二个元素和第三个元素，发现他们的差值都是4个字节，而我们定义的数组的类型是int的，而int类型所占内存的大小也是4个字节。
我们还可以对比一下其他的元素：
我们发现上一个元素于下一个元素的地址差值都是4，这样我们就知道了数组在内存中是连续存储的，而且每个元素所占大小于我们定义数组的类型有关。
注：还有一点就是我们地址是以16进制的形式存储的，所以这里我们的转换成10进制来计算。
2.二维数组的创建和初始化
所谓二维数组有点类似于我们线性代数，有行和列之分。
而我们的二维数组其实和一维数组差不多，甚至是可以吧二维数组看成是一个一维数组的一维数组。
就比如：
1 2 3 4
2 3 4 5
6 7 8 9
这个就是一个三行四列的数组。
2.1二维数组的创建
二维数组的创建方式：
type_t arr_name [row][col];
//row：表示有多少行
//col：表示有多少列
比如：
int arr[3][4];
char arr[3][5];
double arr[2][4];
2.2二维数组的初始化
这里的初始化和一位数组有点相似的，而我们刚才也说过了我们可以通过降维吧二维数组看成是一个一维的一维数组。也就是说我们可以把一行看成是一维数组的第一个元素，以此类推。
这样子我们初始化的时候就得这样子了：
int arr[3] [4]={ {1,2,3,4},{2,3,4,5},{3,4,5,6} };
当然如果我们不给{}也是行的：
int arr[3] [4]={ 1,2,3,4,2,3,4,5,3,4,5,6};
这个时候我们的编译器会自动匹配的。
如果我们不完全初始化呢？也是和一维数组一样编译器会默认初始化为0的。
我们在定义一维数组的时候我们可以省略数组的大小，那是不是说明我们的二维数组也行呢？
答案是肯定的，但是我们只能省略行不能省略列
如果我们省略了列的话，我们知道了行但是不知道一行有多少个元素，这个时候编译器不知道一行的元素够了没，也就不知道要不要默认初始化0，这个时候就出问题了。
2.3二维数组的使用
二维数组的使用也是通过下标的方式。
#include <stdio.h>
int main()
{
int arr[3][4] = {0};
int i = 0;
for(i=0; i<3; i++)
{
int j = 0;
for(j=0; j<4; j++)
{
arr[i][j] = i+j;
}
}
for(i=0; i<3; i++)
{
int j = 0;
for(j=0; j<4; j++)
{
printf("%d ", arr[i][j]);
}
}
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;
}
同样的我们会发现：
发现它的上一个元素和下一个元素的地址的差值还是4，也就是说它的内存分布其实和一维数组是一样的，同样的数组元素是连续存储的，而且元素所占大小取决于定义数组的类型。
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;
}
这类我们的数组大小是10，也就是说我们的数组下标是从0-9的，但是我们的for循环中却遍历数组的下标是从00-10 的明显业界访问了。
4.数组作为函数参数
往往我们在写代码的时候，会将数组作为参数传个函数，比如：我要实现一个冒泡排序（这里要讲算法思想）函数将一个整形数组排序。
4.1冒泡排序的错误设计
#include <stdio.h>
void bubble_sort(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_sort(arr);
int i = 0;
for(i=0; i<sizeof(arr)/sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
return 0;
}
这里看似一点问题都没有，但是当我们运行起来的时候就出问题了。
会发现他根本就没有进行排序。
我们调试看一看：
发现这里的sz是2，按道理我们的sz因该等于数组的大小，也就是10才对，那为什么会这样子呢？
这个时候我们就要明白数组名是什么。
4.2数组名是什么
我们看一下一下代码：
#include <stdio.h>
int main()
{
int arr[10] = {1,2，3,4,5};
printf("%p\n", arr);
printf("%p\n", &arr[0]);
printf("%p\n", arr);
//输出结果
return 0;
}
我们可以看到这三个地址都是一样的也就是说数组名是数组首元素的地址。（有两个例外）
这里为什么会输出40呢。
原因是这里的sizeof（arr）计算的是整个数组的小 10*4=40得到的。
我们再看一下这个：
我们发现&arr于&arr+1之间地址差值是40，也就是说&arr+1跳过了整个数组。
而我们的arr+1于arrr之间的地址的差值却是4，也就是说arr+1跳过了一个元素。
上面充分说明了：
数组名通常是数组的首元素地址，但是有两个例外：
（1）：sizeof（数组名）数组名单独放在sizeof（）内部，这里的数组名表示整个数组，计算的是整个数组的大小
（2）：&数组名，这里的数组名也表示整个数组，这里取出的是整个数组的地址。
除此之外遇到的数组名都表示数组的首元素的地址
这就说得明白为什么上面计算的sz会等于2了。
原因是我们bubble_sort(arr);传过去的是arr（不是那两种特殊情况）所以这里的arr是说元素地址而我们接收的时候，接受的是一个地址，sizeof（arr）计算的是一个地址的大小，而地址的大小取决于我们的硬件（电脑我们电脑分x32位的和x64位的，x32位的电脑一个地址的大小是4个字节，而x64位的电脑一个地址的大小是8个字节，而我们电脑是x64位的），所以sizeof（arr）=8
而sizeof（arr[0])计算的是一个元素的大小，sizeof（arr[0])，8/4==2.
4.3冒泡排序函数的正确设计
所以这里改进的方法就是在主函数里面把sz算出来，然后通过传参传过去。
void bubble_sort(int arr[],int sz)
{
int size = sizeof(arr);
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 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr,sz);
int i = 0;
for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
return 0;
}
