1. 一维数组的创建和初始化
1.1 数组的创建
数组是一组相同类型元素的集合。特点:
- 数组中的每个数据元素都是相同的数据类型。
- 数组是由连续的内存位置组成的。
数组的创建方式:
type_t arr_name[const_n];
type_t:数组的元素类型
const_n:一个常量表达式,用来指定数组的大小
数组创建的实例:
//代码1
int arr1[10];
//代码2
int count = 10;
int arr2[count];//数组什么时候可以正常创建?
//代码3
char arr3[10];
float arr4[1];
double arr5[20];
注意:
- 在 C99 标准之前,[ ]中 数组的大小必须是 常量 或者 常量表达式,不能使用变量。
- 在 C99 标准之后,数组的大小可以是变量,为了支持变长数组(数组的大小通过变量指定,不是指 数组可以改变大小)。
拓展 - 变长数组:
int n = 0; scanf("%d", &n); int arr[n]; int i = 0; fot (i = 0; i < n; i++) { scanf("%d", &arr[i]); }
特点:变长数组在声明时不能同时进行初始化。
1.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[] = "abcdef";
- 数组在创建时如果不指定数组的大小就得初始化。数组的元素个数根据初始化的内容来确定。
- 不完成初始化的话,剩余的元素默认初始化为 0(字符为 '\0')。
- 既不指定数组大小,又没有初始化的话存在语法错误,不算做数组。
但是对于下面的代码要区分,内存中如何分配。
char arr1[] = {'a', 'b', 'c'};//3
char arr2[] = "abc"; //4
注意:采用字符串来初始化字符数组时,字符串结束标志 '0' 算为字符数组中一个字符元素。
1.3 数组的类型
int arr[10] = {0};
该数组的类型为 int [10]。
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;
}
采用 sizeof(arr) / sizeof(arr[0]) 来计算数组的大小。
观察输出的结果我们知道,随着数组下标的增长,元素的地址也在有规律的递增。由此得出结论:数组在内存中是连续存放的。
2. 二维数组的创建和初始化
2.1 二维数组的创建
int arr[3][4];
char arr[3][5];
double arr[2][4];
2.2 二维数组的初始化
int arr[3][4] = {1, 2, 3, 4};
int arr[3][4] = {{1, 2}, {4, 5}};
int arr[][4] = {{2,3}, {4,5}};
不完成初始化的话,剩余的元素默认初始化为 0(字符为 '\0')。
注意:二维数组创建时如果有初始化,行可以省略,列不能省略。行数由初始化决定。
2.3 二维数组的使用
二维数组的使用也是通过下标的方式。
#include <stdio.h>
int main() {
int arr[3][4] = { 1, 2, 3, 4, 2,3,4,5, 3,4,5,6 };
int i = 0, j = 0;
for (i = 0; i < 3; i++) {
for (j = 0; j < 4; j++) {
printf("%d ", arr[i][j]);
}
}
return 0;
}
能不能把二维数组看作一维数组呢?
能,把二维数组中的 每一行(一维数组) 看作一个元素,可以把 二维数组 理解为 一维数组的数组。
2.4 二维数组在内存中的存储
像一维数组一样,我们打印二维数组中的每个元素。
#include <stdio.h>
int main() {
int arr[3][4] = { 1, 2, 3, 4, 2,3,4,5, 3,4,5,6 };
int i = 0, j = 0;
for (i = 0; i < 3; i++) {
for (j = 0; j < 4; j++) {
printf("arr[%d][%d] = %p\n", i, j, &arr[i][j]);
}
}
return 0;
}
通过结果我们可以分析到,其实二维数组在内存中也是连续存储的。
3. 数组越界
数组的下标是有范围限制的:数组的下标访问是从 0 开始的,如果数组有 n 个元素,最后一个元素的下标就是 n - 1。
所以数组的下标如果小于 0,或者大于 n - 1,就是数组越界访问了,超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查,编译器也不一定报错,但是编译器不报错,并不意味着程序就是正确的,所以程序员写代码时,最后自己做越界检查。
#include <stdio.h>
int main() {
int arr[3][4] = { 1, 2, 3, 4, 2,3,4,5, 3,4,5,6 };
int i = 0, j = 0;
for (i = 0; i < 3; i++) {
for (j = 0; j <= 4; j++) {//当 j = 4 时,越界访问了
printf("%d ", arr[i][j]);
}
}
return 0;
}
4. 数组作为函数参数
往往我们在写代码的时候,会将数组作为参数传给函数。
比如:实现一个冒泡排序函数,将一个整型数组排序。
冒泡排序算法:
作用:最常用的排序算法,对数组内元素进行排序
- 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
- 对每一对相邻元素做同样的工作,执行完毕后,找到第一个最大值。
- 重复以上的步骤,每次比较次数 -1,直到不需要比较。
4.1 冒泡排序函数的错误设计
#include <stdio.h>
void bubble_sort(int arr[]) {
int sz = sizeof(arr) / sizeof(arr[0]);//这样做对么?
int i = 0, j = 0;
for (i = 0; i < 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[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
//冒泡排序的核心思想:两个相邻的元素进行比较。
//一轮冒泡排序让一个数据来到它最终应该出现的位置上。
bubble_sort(arr);
for (int i = 0; i < sz; i++) {
printf("%d ", arr[i]);
}
return 0;
}
调试后我们看到 bubble_sort() 函数内部的 sz 是 1。难道数组作为函数参数的时候,不是把整个数组传递过去?
4.2 数组名是什么?
数组传参的时候,实参为数组名,数组名本质上是 数组首元素的地址,地址应该用指针变量来接收,所以函数的数组形参本质是 指针变量。
#include <stdio.h>
int main() {
int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
printf("%p\n", arr);
printf("%p\n", &arr[0]);
return 0;
}
二维数组的数组名也表示数组首元素的地址,此时的首元素为 第 0 行的一维数组,因此二维数组的数组名表示 第 0 行的一维数组 的地址。
#include <stdio.h>
int main() {
int arr[][4] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
printf("%p\n", arr);
printf("%p\n", arr + 1);
printf("%d\n", sizeof(arr) / sizeof(arr[0]));//二维数组的行数
printf("%d\n", sizeof(arr[0]) / sizeof(arr[0][0]));//二维数组的列数
return 0;
}
数组名有两个例外:
- sizeof(数组名):这里的数组名表示整个数组,计算的是整个数组的大小,单位是字节。
- &数组名,这里的数组名表示整个数组,取出的是整个数组的地址。
#include <stdio.h>
int main() {
int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
printf("%p\n", arr);
printf("%p\n", arr + 1);
printf("----------------------\n");
printf("%p\n", &arr[0]);
printf("%p\n", &arr[0] + 1);
printf("----------------------\n");
printf("%p\n", &arr);
printf("%p\n", &arr + 1);
return 0;
}
4.3 冒泡排序函数的正确设计
#include <stdio.h>
void bubble_sort(int arr[], int sz) {
int i = 0, j = 0;
for (i = 0; i < 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[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
int sz = sizeof(arr) / sizeof(arr[0]);
//冒泡排序的核心思想:两个相邻的元素进行比较。
//一轮冒泡排序让一个数据来到它最终应该出现的位置上。
bubble_sort(arr, sz);
for (int i = 0; i < sz; i++) {
printf("%d ", arr[i]);
}
return 0;
}
数组传参的时候,形参有 2 种写法:
- 数组
- 指针