1、一维数组的创建和初始化
1.1 数组的创建
数组是一组相同类型元素的集合。
数组的创建方式:
type_t arr_name [const_n];
// type_t 是指数组的元素类型
// const_n 是一个常量表达式,用来指定数组的大小
数组创建的实例:
// 代码1
int arr1[10];
// 代码2
int count = 10;
int arr2[count];// 代码2的数组可以正常创建?
// 代码3
char arr3[10];
float arr4[1];
double arr5[20];
注意:数组创建,在C99标准之前, [] 中要给一个常量表达式才可以,不能使用变量。在C99标准支持了变长数组的概念,数组的大小可以使用变量指定,但是数组不能初始化。
(VS2019 VS2022 这样的 IDE 不支持 C99 中的变长数组)
用 VSCode(gcc编译器)演示可以用变长数组:
1.2 数组的初始化
数组的初始化是指,在创建数组的同时给数组的内容一些合理初始值(初始化)。
看代码:
int main()
{
int arr1[10] = {1,2,3,4,5,6,7,8,9,10};// 完全初始化
int arr2[10] = { 1,2,3 };// 不完全初始化,剩余的元素默认都是0
int arr3[10] = { 0 };// 不完全初始化,剩余的元素默认都是0
int arr4[] = { 0 };// 省略数组的大小,数组必须初始化,数组的大小是根据初始化的内容来确定
int arr5[] = { 1,2,3 };
//int arr6[];// error
char arr7[] = "abc";
char arr8[] = {'a', 'b', 'c'};
char arr9[] = { 'a', 98, 'c' };
return 0;
}
数组在创建的时候如果想不指定数组的确定的大小就必须得初始化。数组的元素个数根据初始化的内容来确定。
但是对于下面的代码要区分,内存中如何分配。
char arr1[] = "abc";
char arr2[3] = {'a','b','c'};
可以查看上面的 arr7 和 arr8。
1.3 一维数组的使用
对于数组的使用我们之前介绍了一个操作符:[] ,下标引用操作符。它其实就是数组访问的操作符。
看如下代码:
#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++)// 这里写10,好不好?
for (i = 0; i < sz; i++)
{
arr[i] = i;
}
// 输出数组的内容
for (i = 0; i < 10; ++i)
{
printf("%d ", arr[i]);
}
return 0;
}
总结:
1、数组是使用下标来访问的,下标是从0开始。
2、数组的大小可以通过计算得到。
int arr[10];
int sz = sizeof(arr)/sizeof(arr[0]);// 计算数组元素个数的方法
1.4 一维数组在内存中的存储
接下来我们探讨数组在内存中的存储。
看代码:
//%p -- 是用来打印地址的
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5 };
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("&arr[%d] = %p\n", i, &arr[i]);
}
return 0;
}
输出的结果如下:
仔细观察输出的结果,我们知道,随着数组下标的增长,元素的地址,也在有规律的递增。
由此可以得出结论:数组在内存中是连续存放的。
2、二维数组的创建和初始化
2.1 二维数组的创建
// 数组创建
int arr[3][4];
char arr[3][5];
double arr[2][4];
2.2 二维数组的初始化
int main()
{
// 数组的初始化
int arr1[4][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7},{5,6,7,8,9} };
// 不完全初始化,剩余元素默认为0
int arr2[3][4] = { 1,2,3,4,5,6,7 };// 这样初始化,一行放完,再放下一行
int arr3[4][5] = { {1,2,3 }, {2, 3, 4 }, {3, 4, 5, 6, 7}, {5, 6, 7, 8, 9} };
// 二维数组如果有初始化,行可以省略,列不能省略
int arr4[][5] = { {1,2,3 }, {2, 3, 4 }, {3, 4, 5, 6, 7}, {5, 6, 7, 8, 9} };
return 0;
}
2.3 二维数组的使用
二维数组的使用也是通过下标的方式。
二维数组行和列的下标都是从0开始的。
看代码:
#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 * 2 + j;
}
}
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];
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;
}
输出的结果是这样的:
通过结果我们可以分析到,其实二维数组在内存中也是连续存储的。
为什么二维数组初始化时,可以忽略行,不可以忽略列?
因为二维数组在内存中是连续存放的,只有知道一行有几个元素,才能确定下一行放哪。
思考如下:
二维数组是【一维数组】的数数组。
arr[0]是第一行的数组名;arr[1]是第二行的数组名;arr[2]是第三行的数组名;arr[3]是第四行的数组名。
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;
}
二维数组的行和列也可能存在越界。
4、数组作为函数参数
往往我们在写代码的时候,会将数组作为参数传个函数,比如:我要实现一个冒泡排序函数将一个整形数组排序。
介绍冒泡排序:
排序有很多的方法
1、冒泡排序
2、选择排序
3、插入排序
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++)
{
scanf("%d", &arr[i]);
}
// 冒泡排序 - 升序
// 趟数
for (i = 0; i < sz - 1; i++)
{
int j = 0;
// 一趟比较(sz - 1 - i)次
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;
}
}
}
// 排序后打印
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
那我们将会这样使用该函数:
4.1 冒泡排序函数的错误设计
// 方法2
#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;
// 一趟比较(sz - 1 - i)次
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;
}
}
}
}
int main()
{
int arr[10] = { 0 };
//输入
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < sz; i++)
{
scanf("%d", &arr[i]);
}
// 冒泡排序 - 升序
bubble_sort(arr);
// 排序后打印
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
方法1,出问题了,并没有完成排序,那我们找一下问题。
调试之后可以看到 bubble_sort
函数内部的 sz,是1。
如果 sz = 1,则根据后面的代码,压根没有排序。
难道数组作为函数参数的时候,不是把整个数组的传递过去?
arr 作为数组进行了传参;数组传参,传递的是地址,传递的是首元素的地址。
下面虽然写的是数组,但本质上是指针。
因此:
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("%d\n", *arr);
return 0;
}
结论: 数组名通常是数组首元素的地址。(有两个例外)
如果数组名是首元素地址,那么:
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%d\n", sizeof(arr));
return 0;
}
为什么输出的结果是40?如果数组名是首元素地址,为什么不是4/8呢?
结论:(重要!!!)
1、sizeof(数组名),数组名单独放在sizeof()内部,这里的数组名表示整个数组,计算的是整个数组的大小。
2、&数组名,这里的数组名也表示整个数组,这里取出的是整个数组的地址
除此1,2两种情况之外,所有的数组名都表示数组首元素的地址。
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6 };
printf("%p\n", arr);// 数组首元素的地址
printf("%p\n", arr+1);// +1,跳过一个整型
printf("%p\n", &arr[0]);
printf("%p\n", &arr[0]+1);
printf("%p\n", &arr);// 数组的地址
printf("%p\n", &arr+1);// +1,跳过整个数组
printf("sizeof(arr) = %d\n", sizeof(arr));
return 0;
}
上面代码虽然 arr,&arr[0] 和 &arr 一样,但是注意 +1 不一样。
010FFAF0 - 010FFAEC = 4 (16进制) = 4 (10进制) 4字节 - 一个整型的大小
010FFB14 - 010FFAEC = 28(16进制) = 40(10进制) 40字节 - 一个数组的大小
因为是整型数组,arr,&arr[0] 加1,跳过一个整型,&arr 加1,跳过整个数组,因为 &arr 的数组名表示整个数组的地址。
4.3 冒泡排序函数的正确设计
当数组传参的时候,实际上只是把数组的首元素的地址传递过去了。
所以即使在函数参数部分写成数组的形式:int arr[]
表示的依然是一个指针:int *arr
。
那么,函数内部的 sizeof(arr)
结果是4。
如果方法1错了,该怎么设计?
// 方法2
// 再加一个参数,表示数组元素个数
#include <stdio.h>
// 数组传参,形参可以是指针,也可以是数组的形式
// 形参写成数组是为了方便理解,但是本质上还是指针
// void bubble_sort(int arr[], int sz)// 这种写法,和下面的写法本质是一样的,都可以用
void bubble_sort(int* arr, int sz)
{
// 冒泡排序 - 升序
// 趟数
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
// 一趟比较(sz - 1 - i)次
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;
}
}
}
}
int main()
{
int arr[10] = { 0 };
//输入
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < sz; i++)
{
scanf("%d", &arr[i]);
}
// 冒泡排序 - 升序
bubble_sort(arr, sz);
// 排序后打印
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
对冒泡排序做优化:
#include <stdio.h>
void bubble_sort(int* arr, int sz)// 这里的arr的本质是指针
{
// 冒泡排序 - 升序
// 趟数
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
// 每一趟开始前就假设已经有序了
int flag = 1;
// 一趟比较(sz - 1 - i)次
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;// 发生了交换,就表示无序,置为0
}
}
if (flag == 1)
break;
}
}
int main()
{
int arr[10] = { 0 };
//输入
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < sz; i++)
{
scanf("%d", &arr[i]);
}
// 冒泡排序 - 升序
bubble_sort(arr, sz);
// 排序后打印
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
很明显,上述代码,只能对接近有序的数组做优化。