数组
一、 一维数组的创建和初始化
1.数组的创建
数组是一组相同类型元素的集合
数组创建的格式：
type_t arr_name [const_n];
//type_t 是指数组的元素类型
//const_n 是一个 常量 表达式，用来指定数组的大小
成功创建：
错误案例：(vs2022编译器环境下)
[]里面必须是常数表达式！
但在vscode（gcc）环境下可以正常创建
这里提出一个名词：变长数组，因为只有在c99往后的标准才允许
（ps：数组的大小可以使用变量指定，但是数组不能初始化）
2.数组的初始化
数组的初始化指：在创建数组的同时给数组的内容一些合理初始值（初始化）。
演示案例：
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[] = "abc";
char arr7[] = "abcdef";
(ps1：数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。)
对比
char arr1[] = { 'a','b','c' };
char arr2[] = "abc";
这俩看起来一样 实际上完全不一样。
将第二个转化为第一个格式其实是： char arr1[4] = { ‘a’,‘b’,‘c’ ,‘\0’};
(ps: ‘\0’ 也是占一个元素位置的。)
3.数组的使用
数组的使用是：通过下标引用([ ])实现的。
（ps：数组是使用下标来访问的，下标从0开始）
#include<stdio.h>
int main()
{
int arr1[10] = { 0,1,2,3,4,5,6,7,8,9 };
for (int i = 0; i < 10; i++)
{
printf("%d " ,arr1[i]);
}
}
运行结果：
4.数组在内存中的存储
#include<stdio.h>
int main()
{
int arr1[10] = { 0,1,2,3,4,5,6,7,8,9 };
for (int i = 0; i < 10; i++)
{
printf("%p\n" ,&arr1[i]);
}
}
运行结果：
可以明显看出数组每次地址都是加4，这是因为数组元素是int型，单位是四个字节，所以每四个字节存放一个数组元素的地址，并且数组在内存中是连续存放的。
（ps:0x代表是16进制储存，并且a,b,c… 分别代表10进制的11，12，13…）
二、 二维数组的创建和初始化
1.数组的创建
数组创建的格式：
格式和一维数组很像，都是用下标引用符，不过因为是二维数组需要用俩引用符而已。
2.数组的初始化
ps:二维数组如果有初始化，行可以省略，列不能省略。因为列决定了二维数组一行有多少元素。
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 * 4 + j;
}
}
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 4; j++)
{
printf("%d ", arr[i][j]);
}
}
return 0;
}
运行结果：
4.数组在内存中的存储
#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 * 4 + j;
}
}
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 4; j++)
{
printf("%p\n", &arr[i][j]);
}
}
return 0;
}
运行结果：
可以看到即使是二维数组，即使是换行也不影响他是连续储存
三、函数越界
数组的下标是有范围限制的。
数组的下规定是从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;
}
运行结果：
ps:二维数组的行和列也可能存在越界。
四、 数组作为函数参数
扩：1.求数组长度
#include<stdio.h>
int main()
{
int sz = 0;
int arr1[10] = { 0, 1, 2, 3, 4};
sz = sizeof(arr1) / sizeof(arr1[0]);
printf("%d", sz);
return 0;
}
运行结果：
从运行结果可以看出求出来的数组长度是数组实际长度。不是你里面有几个初始化元素，数组长度就是几。
2.冒泡函数
1）版本1：
（不分装，在一个main函数里面实现）
#include<stdio.h>
int main()
{
int arr1[10] = { 0 };
int a = 0;
int sz = sizeof(arr1) / sizeof(arr1[0]);
//初始化数组
for (int i = 0; i < sz; i++)
{
scanf("%d", &arr1[i]);
}
//冒泡函数的实现
for (int j = 0; j<sz; j++)
{
int flag = 0;
for (int i2 = 0; i2 < sz - 1 - j; i2++)
{
if (arr1[i2] > arr1[i2 + 1])
{
arr1[i2] = arr1[i2] + arr1[i2 + 1];
arr1[i2 + 1] = arr1[i2] - arr1[i2 + 1];
arr1[i2] = arr1[i2] - arr1[i2 + 1];
flag = 1;
}
if (flag == 0)
{
break;
}
}
//打印数组
for (int i = 0; i < sz; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
2）版本2：（有一定错误）
按部就班的把主函数里面的实现部分分装到一个函数里面
//2.0版本
int bubble_sort(int arr1[10])
//冒泡函数的实现
int sz = sizeof(arr1) / sizeof(arr1[10]);
for (int j = 0; j < sz; j++)
{
int flag = 0;
for (int i2 = 0; i2 < sz - 1 - j; i2++)
{
if (arr1[i2] > arr1[i2 + 1])
{
arr1[i2] = arr1[i2] + arr1[i2 + 1];
arr1[i2 + 1] = arr1[i2] - arr1[i2 + 1];
arr1[i2] = arr1[i2] - arr1[i2 + 1];
flag = 1;
}
}
if (flag == 0)
{
break;
}
}
}
//冒泡函数
#include<stdio.h>
int main()
{
int arr1[10] = { 0 };
int a = 0;
//初始化数组
for (int i = 0; i < 10; i++)
{
scanf("%d", &arr1[i]);
}
int bubble_sort(arr1);
//打印数组
for (int i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
运行结果：
通过运行结果可以发现并不能很好的实现想要实现的功能
通过调用监视发现了一些问题：
这个sz明明应该求出来是10才对，但是这里并不是10，而是1，这就牵扯到了传参方面的问题。
如果把sz提到主函数去
3） 版本3：
int bubble_sort(int arr2[10],int sz)
{
//冒泡函数的实现
for (int j = 0; j < sz; j++)
{
int flag = 0;
for (int i2 = 0; i2 < sz - 1 - j; i2++)
{
if (arr2[i2] > arr2[i2 + 1])
{
arr2[i2] = arr2[i2] + arr2[i2 + 1];
arr2[i2 + 1] = arr2[i2] - arr2[i2 + 1];
arr2[i2] = arr2[i2] - arr2[i2 + 1];
flag = 1;
}
}
if (flag == 0)
{
break;
}
}
}
//冒泡函数
#include<stdio.h>
int main()
{
int arr1[10] = { 0 };
int a = 0;
int sz = sizeof(arr1) / sizeof(arr1[0]);
//初始化数组
for (int i = 0; i < sz; i++)
{
scanf("%d", &arr1[i]);
}
bubble_sort(arr1, sz);
//打印数组
for (int i = 0; i < sz; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
运行结果：
到这里一个完整的冒泡函数算是完成了
（ps：在冒泡函数中的形参arr看起来是数组 实则只是个指针，改成图中这样的也是完全可以运行的！！！）
4）数组名的含义
由代码和运行结果可以看出：数组名是数组首元素的地址。
但是有两个例外：
例1：
这里的结果是40，那么说明sizeof里面的数组名可不是首元素的地址，更像是整个数组
（ps：这里不用提strlen，strlen只有在字符数组的时候，才能和sizeof功能进行比较）
例2：
通过这个图又可以发现 &arr似乎代表的也不是首元素的地址，明显可以看出这是加了一个数组的地址。
总结：
-
sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整数组。
-
&数组名，取出的是数组的地址。&数组名，数组名表示整个数组。
扫一扫
2282
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
