mirror of
https://github.com/Aexiar/c.git
synced 2024-10-22 14:05:45 +02:00
2131 lines
64 KiB
Markdown
2131 lines
64 KiB
Markdown
# 第一章：数组的概念
|
||
|
||
## 1.1 为什么需要数组？
|
||
|
||
### 1.1.1 需求分析 1
|
||
|
||
* 需要统计某公司 50 个员工的工资情况，例如：计算平均工资、最高工资等。如果使用之前的知识，我们需要声明 50 个变量来分别记录每位员工的工资，即：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main(){
|
||
|
||
double num1 = 0;
|
||
double num2 = 0;
|
||
double num3 = 0;
|
||
...
|
||
printf("请输入第 1 个员工的工资：");
|
||
scanf("%lf",&num1);
|
||
printf("请输入第 2 个员工的工资：");
|
||
scanf("%lf",&num2);
|
||
printf("请输入第 3 个员工的工资：");
|
||
scanf("%lf",&num3);
|
||
...
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
* 这样会感觉特别机械和麻烦（全是复制（Ctrl + c）和粘贴（Ctrl + v），CV 大法）；此时，我们就可以将所有的`数据`全部存储到一个`容器（数组）`中进行统一管理，并进行其它的操作，如：求最值、求平均值等，如下所示：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main(){
|
||
// 声明数组
|
||
double nums[50];
|
||
// 数组的长度
|
||
int length = sizeof(nums) / sizeof(double);
|
||
// 使用 for 循环向数组中添加值
|
||
for(int i = 0;i < length;i++){
|
||
printf("请输入第 &d 个员工的工资：",i);
|
||
scanf("%lf",&num[i]);
|
||
}
|
||
// 其它操作，如：求最值，求平均值等
|
||
...
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 1.1.2 需求分析 2
|
||
|
||
* 在现实生活中，我们会使用很多 APP 或微信小程序等，即：
|
||
|
||
|
||
|
||
* 同样的道理，如果我们使用变量来存储每个商品信息，那么就需要非常多的变量；但是，如果我们将这些`商品信息`都存储到一个`容器（数组）`中，进行统一管理；那么，之后的数据处理将会非常方便。
|
||
|
||
### 1.1.3 容器的概念
|
||
|
||
* `生活中的容器`：水杯（装水、饮料的容器）、衣柜（装衣服等物品的容器）、集装箱（装货物等物品的容器）。
|
||
* `程序中的容器`：将多个数据存储到一起，并且每个数据称为该容器中的元素。
|
||
|
||
## 1.2 什么是数组？
|
||
|
||
* 数组（Array）是将多个`相同数据类型`的`数据`按照一定的顺序排序的`集合`，并使用一个`标识符`命名，以及通过`编号（索引，亦称为下标）`的方式对这些数据进行统一管理。
|
||
|
||
|
||
|
||
## 1.3 数组的相关概念
|
||
|
||
* `数组名`：本质上是一个标识符常量，命名需要符合标识符规则和规范。
|
||
* `元素`：同一个数组中的元素必须是相同的数据类型。
|
||
* `索引（下标）`：从 0 开始的连续数字。
|
||
* `数组的长度`：就是元素的个数。
|
||
|
||
## 1.4 数组的特点
|
||
|
||
* ① 创建数组的时候，会在内存中开辟一整块`连续的空间`，占据空间的大小，取决于数组的长度和数组中元素的类型。
|
||
* ② 数组中的元素在内存中是依次紧密排列且有序的。
|
||
* ③ 数组一旦初始化完成，且长度就确定的，并且`数组的长度一旦确定，就不能更改`。
|
||
* ④ 我们可以直接通过索引（下标）来获取指定位置的元素，速度很快。
|
||
* ⑤ 数组名中引用的是这块连续空间的首地址。
|
||
|
||
|
||
# 第二章：数组的操作（⭐）
|
||
|
||
## 2.1 数组的定义
|
||
|
||
### 2.1.1 动态初始化
|
||
|
||
* 语法：
|
||
|
||
```c
|
||
数据类型 数组名[元素个数|长度];
|
||
```
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 数据类型：表示的是数组中每一个元素的数据类型。
|
||
> * ② 数组名：必须符合标识符规则和规范。
|
||
> * ③ 元素个数或长度：表示的是数组中最多可以容纳多少个元素（不能是负数、也不能是 0 ）。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 先指定元素的个数和类型，再进行初始化
|
||
|
||
// 定义数组
|
||
int arr[3];
|
||
|
||
// 给数组元素赋值
|
||
arr[0] = 10;
|
||
arr[1] = 20;
|
||
arr[2] = 30;
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 2.1.2 静态初始化 1
|
||
|
||
* 语法：
|
||
|
||
```c
|
||
数据类型 数组名[元素个数|长度] = {元素1,元素2,...}
|
||
```
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 静态部分初始化：如果数组初始化的元素个数`小于`数组声明的长度，那么就会从数组开始位置依次赋值，不够的就补 0 。
|
||
> * ② 静态全部初始化：数组初始化的元素个数`等于`数组的长度。
|
||
|
||
> [!TIP]
|
||
>
|
||
> 在 CLion 中开启`嵌入提示（形参名称-->显示数组索引的提示）`功能，即：
|
||
>
|
||
> 
|
||
>
|
||
> 这样，在 CLion 中，将会显示数组初始化时每个元素对应的索引，即：
|
||
>
|
||
> 
|
||
|
||
|
||
|
||
* 示例：静态部分初始化
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组和部分初始化：
|
||
// 会将给定的值从数组的开始位置一个个的赋值，没有赋值的地方，用 0 填充
|
||
int arr[5] = {1, 2};
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
* 示例：静态全部初始化
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组和全部初始化：数组初始化的元素个数等于数组的长度。
|
||
int arr[5] = {1, 2, 3, 4, 5};
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 2.1.3 静态初始化 2
|
||
|
||
* 语法：
|
||
|
||
```c
|
||
数据类型 数组名[] = {元素1,元素2,...}
|
||
```
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 没有给出数组中元素的个数，将由系统根据初始化的元素，自动推断出数组中元素的个数。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 指定元素的类型，不指定元素个数，同时进行初始化
|
||
int arr[] = {1, 2, 3, 4, 5};
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 2.1.4 静态初始化 3
|
||
|
||
* 在 C 语言中，也可以只给部分元素赋值。当 {} 中的值少于元素的个数的时候，只会给前面的部分元素赋值，至于剩下的元素就会自动初始化为 0 。
|
||
|
||
```c
|
||
int arr[10] = {1,2,3,4,5};
|
||
```
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 数组 `arr` 在内存中开辟了 `10` 个连续的内存空间，但是只会给前 `5` 个内存空间赋值初始化值，即：`arr[0] ~ arr[4]` 分别是 `1`、`2`、`3`、`4`、`5`，而 `arr[5] ~ arr[9]` 就会被自动初始化为 `0` 。
|
||
> * ② 当赋值的元素少于数组总体元素的时候，剩余的元素自动初始化为 `0`，其规则如下：
|
||
> * 对于 `short`、`int`、`long`，就是整数 `0`。
|
||
> * 对于 `char`，就是字符 `'\0'`。需要注意的是，`'\0'` 的十进制数就是 `0` 。
|
||
> * 对于 `float`、`double`，就是小数 `0.0`。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
int main() {
|
||
int arr[10] = {1, 2, 3, 4, 5};
|
||
|
||
printf("arr[0] = %d \n", arr[0]); // arr[0] = 1
|
||
printf("arr[1] = %d \n", arr[1]); // arr[1] = 2
|
||
printf("arr[2] = %d \n", arr[2]); // arr[2] = 3
|
||
printf("arr[3] = %d \n", arr[3]); // arr[3] = 4
|
||
printf("arr[4] = %d \n", arr[4]); // arr[4] = 5
|
||
printf("arr[5] = %d \n", arr[5]); // arr[5] = 0
|
||
printf("arr[6] = %d \n", arr[6]); // arr[6] = 0
|
||
printf("arr[7] = %d \n", arr[7]); // arr[7] = 0
|
||
printf("arr[8] = %d \n", arr[8]); // arr[8] = 0
|
||
printf("arr[9] = %d \n", arr[9]); // arr[9] = 0
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
## 2.2 访问数组元素
|
||
|
||
* 语法：
|
||
|
||
```c
|
||
数组名[索引|下标];
|
||
```
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 假设数组 `arr` 有 n 个元素，如果使用的数组的下标 `< 0` 或 `> n-1` ，那么将会产生数组越界访问，即超出了数组合法空间的访问；那么，数组的索引范围是 `[0,arr.length - 1]`。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 先指定元素的个数和类型，再进行初始化
|
||
|
||
// 定义数组
|
||
int arr[3];
|
||
|
||
// 给数组元素赋值
|
||
arr[0] = 10;
|
||
arr[1] = 20;
|
||
arr[2] = 30;
|
||
|
||
// 访问数组元素
|
||
printf("arr[0] = %d\n", arr[0]); // arr[0] = 10
|
||
printf("arr[1] = %d\n", arr[1]); // arr[1] = 20
|
||
printf("arr[2] = %d\n", arr[2]); // arr[2] = 30
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组和部分初始化：
|
||
// 会将给定的值从数组的开始位置一个个的赋值，没有赋值的地方，用 0 填充
|
||
int arr[5] = {1, 2};
|
||
|
||
// 访问数组元素
|
||
printf("arr[0] = %d\n", arr[0]); // arr[0] = 1
|
||
printf("arr[1] = %d\n", arr[1]); // arr[1] = 2
|
||
printf("arr[2] = %d\n", arr[2]); // arr[2] = 0
|
||
printf("arr[3] = %d\n", arr[3]); // arr[3] = 0
|
||
printf("arr[4] = %d\n", arr[4]); // arr[4] = 0
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 指定元素的类型，不指定元素个数，同时进行初始化
|
||
int arr[] = {1, 2, 3, 4, 5};
|
||
|
||
// 访问数组元素
|
||
printf("arr[0] = %d\n", arr[0]); // arr[0] = 1
|
||
printf("arr[1] = %d\n", arr[1]); // arr[1] = 2
|
||
printf("arr[2] = %d\n", arr[2]); // arr[2] = 3
|
||
printf("arr[3] = %d\n", arr[3]); // arr[3] = 4
|
||
printf("arr[4] = %d\n", arr[4]); // arr[4] = 5
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组和全部初始化：数组初始化的元素个数等于数组的长度。
|
||
int arr[5] = {1, 2, 3, 4, 5};
|
||
|
||
// 访问数组元素
|
||
printf("arr[0] = %d\n", arr[0]); // arr[0] = 1
|
||
printf("arr[1] = %d\n", arr[1]); // arr[1] = 2
|
||
printf("arr[2] = %d\n", arr[2]); // arr[2] = 3
|
||
printf("arr[3] = %d\n", arr[3]); // arr[3] = 4
|
||
printf("arr[4] = %d\n", arr[4]); // arr[4] = 5
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
## 2.3 数组越界
|
||
|
||
* 数组下标必须在指定范围内使用，超出范围视为越界。
|
||
|
||
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① C 语言是不会做数组下标越界的检查，并且编译器也不会报错；但是，编译器不报错，并不意味着程序就是正确！
|
||
> * ② 在其它高级编程语言，如：Java、JavaScript、Rust 等中，如果数组越界访问，编译器是会直接报错的！！！
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组和全部初始化：数组初始化的元素个数等于数组的长度。
|
||
int arr[] = {1, 2, 3, 4, 5};
|
||
|
||
// 访问数组元素
|
||
printf("arr[0] = %d\n", arr[0]); // arr[0] = 1
|
||
printf("arr[1] = %d\n", arr[1]); // arr[1] = 2
|
||
printf("arr[2] = %d\n", arr[2]); // arr[2] = 3
|
||
printf("arr[3] = %d\n", arr[3]); // arr[3] = 4
|
||
printf("arr[4] = %d\n", arr[4]); // arr[4] = 5
|
||
printf("arr[-1] = %d\n", arr[-1]); // 得到的是不确定的结果
|
||
printf("arr[5] = %d\n", arr[5]); // 得到的是不确定的结果
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
## 2.4 计算数组的长度
|
||
|
||
* 数组长度（元素个数）是在数组定义的时候明确指定且固定的，我们不能在运行的时候直接获取数组长度；但是，我们可以通过 sizeof 运算符间接计算出数组的长度。
|
||
* 计算步骤，如下所示：
|
||
* ① 使用 sizeof 运算符计算出整个数组的字节长度。
|
||
* ② 由于数组成员是同一数据类型；那么，每个元素的字节长度一定相等，那么`数组的长度 = 整个数组的字节长度 ÷ 单个元素的字节长度 `。
|
||
|
||
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 在很多编程语言中，都内置了获取数组的长度的属性或方法，如：Java 中的 arr.length 或 Rust 的 arr.len()。
|
||
> * ② 但是，C 语言没有内置的获取数组长度的属性或方法，只能通过 sizeof 运算符间接来计算得到。
|
||
> * ③ 数组一旦`声明`或`定义`，其`长度`就`固定`了，`不能动态变化`。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组和全部初始化：数组初始化的元素个数等于数组的长度。
|
||
int arr[] = {1, 2, 3, 4, 5};
|
||
|
||
// 计算数组的长度
|
||
size_t length = sizeof(arr) / sizeof(arr[0]);
|
||
|
||
// 遍历数组
|
||
for (int i = 0; i < length; i++) {
|
||
printf("%d \n", arr[i]);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
## 2.5 遍历数组
|
||
|
||
* 遍历数组是指按顺序访问数组中的每个元素，以便读取或修改它们，编程中一般使用循环结构对数组进行遍历。
|
||
|
||
|
||
|
||
* 示例：声明一个存储有 12、2、31、24、15、36、67、108、29、51 的数组，并遍历数组所有元素
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组并初始化
|
||
int arr[] = {12, 2, 31, 24, 15, 36, 67, 108, 29, 51};
|
||
|
||
// 计算数组的长度
|
||
size_t length = sizeof(arr) / sizeof(int);
|
||
|
||
// 遍历数组
|
||
for (int i = 0; i < length; i++) {
|
||
printf("%d\n", arr[i]);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
* 示例：声明长度为 10 的 int 类型数组，给数组元素依次赋值为 0 ~ 9 ，并遍历数组所有元素
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组
|
||
int arr[10];
|
||
|
||
// 计算数组的长度
|
||
size_t length = sizeof(arr) / sizeof(int);
|
||
|
||
// 给数组的每个元素赋值
|
||
for (int i = 0; i < length; i++) {
|
||
arr[i] = i;
|
||
}
|
||
|
||
// 遍历数组
|
||
for (int i = 0; i < length; i++) {
|
||
printf("%d\n", arr[i]);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
## 2.6 一维数组的内存分析
|
||
|
||
### 2.6.1 数组内存图
|
||
|
||
* 假设数组是如下的定义：
|
||
|
||
```c
|
||
int arr[] = {1,2,3,4,5};
|
||
```
|
||
|
||
* 那么，对应的内存结构，如下所示：
|
||
|
||
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 数组名 `arr` 就是记录该数组的首地址，即 `arr[0]` 的地址。
|
||
> * ② 数组中的各个元素是连续分布的，假设 `arr[0]` 的地址是 `0xdea7bff880`，则 `arr[1] 的地址 = arr[0] 的地址 + int 字节数（4） = 0xdea7bff880 + 4 = 0xdea7bff884` ，依次类推...
|
||
|
||
* 在 C 语言中，我们可以通过 `&arr` 或 `&arr[0]` 等形式获取数组或数组元素的地址，即：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组
|
||
int arr[10];
|
||
|
||
// 计算数组的长度
|
||
size_t length = sizeof(arr) / sizeof(int);
|
||
|
||
// 给数组的每个元素赋值
|
||
for (int i = 0; i < length; i++) {
|
||
arr[i] = i;
|
||
}
|
||
|
||
printf("数组的地址是 = %p\n", arr);
|
||
|
||
// 遍历数组
|
||
for (int i = 0; i < length; i++) {
|
||
printf("数组元素 %d 的地址是 = %p\n", arr[i], &arr[i]);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 2.6.2 数组的注意事项
|
||
|
||
* `C 语言规定，数组一旦声明，数组名指向的地址将不可更改`。因为在声明数组的时候，编译器会自动会数组分配内存地址，这个地址和数组名是绑定的，不可更改。
|
||
|
||
> [!WARNING]
|
||
>
|
||
> 如果之后试图更改数组名对应的地址，编译器就会报错。
|
||
|
||
|
||
|
||
* 示例：错误演示
|
||
|
||
```c
|
||
int num[5]; // 声明数组
|
||
|
||
// 使用大括号重新赋值是不允许的，必须在数组声明的时候赋值，否则编译将会报错
|
||
num = {1,2,3,4,5} ; // [!code error]
|
||
```
|
||
|
||
|
||
|
||
* 示例：错误演示
|
||
|
||
```c
|
||
int num[] = {1,2,3,4,5};
|
||
|
||
// 使用大括号重新赋值是不允许的，必须在数组声明的时候赋值，否则编译将会报错
|
||
num = {2,3,4,5,6}; // [!code error]
|
||
```
|
||
|
||
|
||
|
||
* 示例：错误演示
|
||
|
||
```c
|
||
int num[5];
|
||
|
||
// 报错，需要和 Java 区别一下，在 C 中不可以
|
||
num = NULL; // [!code error]
|
||
```
|
||
|
||
|
||
|
||
* 示例：错误演示
|
||
|
||
```c
|
||
int a[] = {1,2,3,4,5}
|
||
|
||
// 报错，需要和 Java 区别一下，在 C 中不可以
|
||
int b[5] = a ; // [!code error]
|
||
```
|
||
|
||
## 2.7 数组应用案例
|
||
|
||
### 2.7.1 应用示例
|
||
|
||
* 需求：计算数组中所有元素的和以及平均数。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组并初始化
|
||
int arr[] = {12, 2, 31, 24, 15, 36, 67, 108, 29, 51};
|
||
|
||
// 计算数组的长度
|
||
size_t length = sizeof(arr) / sizeof(int);
|
||
|
||
// 变量保存总和
|
||
int sum = 0;
|
||
|
||
// 遍历数组
|
||
for (int i = 0; i < length; i++) {
|
||
sum += arr[i];
|
||
}
|
||
|
||
double avg = (double)sum / length;
|
||
printf("数组的和为：%d\n", sum); // 数组的和为：375
|
||
printf("数组的平均值为：%.2lf\n", avg); //数组的平均值为：37.50
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 2.7.2 应用示例
|
||
|
||
* 需求：计算数组的最值（最大值和最小值）。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 思路：
|
||
>
|
||
> * ① 假设数组中的第一个元素是最大值或最小值，并使用变量 max 或 min 保存。
|
||
> * ② 遍历数组中的每个元素：
|
||
> * 如果有元素比最大值还要大，就让变量 max 保存最大值。
|
||
> * 如果有元素比最小值还要小，就让变量 min 保存最小值。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组并初始化
|
||
int arr[] = {12, 2, 31, 24, 15, -36, 67, 108, 29, 51};
|
||
|
||
// 计算数组的长度
|
||
size_t length = sizeof(arr) / sizeof(int);
|
||
|
||
// 定义最大值
|
||
int max = arr[0];
|
||
// 定义最小值
|
||
int min = arr[0];
|
||
|
||
// 遍历数组
|
||
for (int i = 0; i < length; i++) {
|
||
if (arr[i] >= max) {
|
||
max = arr[i];
|
||
}
|
||
if (arr[i] <= min) {
|
||
min = arr[i];
|
||
}
|
||
}
|
||
|
||
printf("数组的最大值为：%d\n", max); // 数组的最大值为：108
|
||
printf("数组的最小值为：%d\n", min); // 数组的最小值为：-36
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 2.7.3 应用示例
|
||
|
||
* 需求：统计数组中某个元素出现的次数，要求：使用无限循环，如果输入的数字是 0 ，就退出。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组并初始化
|
||
int arr[] = {12, 2, 31, 24, 2, -36, 67, 108, 29, 51};
|
||
|
||
// 计算数组的长度
|
||
size_t length = sizeof(arr) / sizeof(int);
|
||
|
||
// 遍历数组
|
||
printf("当前数组中的元素是：");
|
||
for (int i = 0; i < length; i++) {
|
||
printf("%d ", arr[i]);
|
||
}
|
||
|
||
printf("\n");
|
||
|
||
// 无限循环
|
||
while (true) {
|
||
// 统计的数字
|
||
int num;
|
||
// 统计数字出现的次数
|
||
int count = 0;
|
||
// 输入数字
|
||
printf("请输入要统计的数字：");
|
||
scanf("%d", &num);
|
||
|
||
// 0 作为结束条件
|
||
if (num == 0) {
|
||
break;
|
||
}
|
||
|
||
// 遍历数组，并计数
|
||
for (int i = 0; i < length; i++) {
|
||
if (arr[i] == num) {
|
||
count++;
|
||
}
|
||
}
|
||
|
||
printf("您输入的数字 %d 在数组中出现了 %d 次\n", num, count);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 2.7.4 应用示例
|
||
|
||
* 需求：将数组 a 中的全部元素复制到数组 b 中。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
#define SIZE 10
|
||
|
||
int main() {
|
||
|
||
// 定义数组并初始化
|
||
int a[] = {12, 2, 31, 24, 15, -36, 67, 108, 29, 51};
|
||
int b[SIZE];
|
||
|
||
// 复制数组
|
||
for (int i = 0; i < SIZE; i++) {
|
||
b[i] = a[i];
|
||
}
|
||
|
||
// 打印数组 b 中的全部元素
|
||
for (int i = 0; i < SIZE; i++) {
|
||
printf("%d ", b[i]);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 2.7.5 应用示例
|
||
|
||
* 需求：数组对称位置的元素互换。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 思路：假设数组一共有 10 个元素，那么：
|
||
>
|
||
> * a[0] 和 a[9] 互换。
|
||
> * a[1] 和 a[8] 互换。
|
||
> * ...
|
||
>
|
||
> 规律就是 `a[i] <--互换--> arr[arr.length -1 -i]`
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 原始数组
|
||
int arr[] = {12, 2, 31, 24, 15, -36, 67, 108, 29, 51};
|
||
|
||
// 计算数组的长度
|
||
size_t SIZE = sizeof(arr) / sizeof(arr[0]);
|
||
|
||
// 打印原始数组中的全部元素
|
||
printf("原始数组：");
|
||
for (int i = 0; i < SIZE; i++) {
|
||
printf("%d ", arr[i]);
|
||
}
|
||
printf("\n");
|
||
|
||
// 交换数组
|
||
for (int i = 0; i < SIZE / 2; i++) {
|
||
int temp = arr[i];
|
||
arr[i] = arr[SIZE - 1 - i];
|
||
arr[SIZE - 1 - i] = temp;
|
||
}
|
||
|
||
// 打印交换后的数组
|
||
printf("交换后数组：");
|
||
for (int i = 0; i < SIZE; i++) {
|
||
printf("%d ", arr[i]);
|
||
}
|
||
printf("\n");
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 原始数组
|
||
int arr[] = {12, 2, 31, 24, 15, -36, 67, 108, 29, 51};
|
||
|
||
// 计算数组的长度
|
||
size_t SIZE = sizeof(arr) / sizeof(arr[0]);
|
||
|
||
// 打印原始数组中的全部元素
|
||
printf("原始数组：");
|
||
for (int i = 0; i < SIZE; i++) {
|
||
printf("%d ", arr[i]);
|
||
}
|
||
printf("\n");
|
||
|
||
// 交换数组
|
||
for (int i = 0, j = SIZE - 1 - i; i < SIZE / 2; i++, j--) {
|
||
int temp = arr[i];
|
||
arr[i] = arr[j];
|
||
arr[j] = temp;
|
||
}
|
||
|
||
// 打印交换后的数组
|
||
printf("交换后数组：");
|
||
for (int i = 0; i < SIZE; i++) {
|
||
printf("%d ", arr[i]);
|
||
}
|
||
printf("\n");
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 2.7.6 应用示例
|
||
|
||
* 需求：将数组中的最大值移动到数组的最末尾。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 思路：从数组的下标 `0` 开始依次遍历到 `length - 1` ，如果 `i` 下标当前的值比 `i+1` 下标的值大，则交换；否则，就不交换。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 原始数组
|
||
int arr[] = {12, 2, 31, -24, 15, -36, 67, 891, 29, 51};
|
||
|
||
// 计算数组的长度
|
||
size_t length = sizeof(arr) / sizeof(arr[0]);
|
||
|
||
// 打印原始数组中的全部元素
|
||
printf("原始数组：");
|
||
for (int i = 0; i < length; i++) {
|
||
printf("%d ", arr[i]);
|
||
}
|
||
printf("\n");
|
||
|
||
// 移动最大值到数组的最后一个位置
|
||
for (int i = 0; i < length - 1; i++) {
|
||
if (arr[i] > arr[i + 1]) {
|
||
int temp = arr[i];
|
||
arr[i] = arr[i + 1];
|
||
arr[i + 1] = temp;
|
||
}
|
||
}
|
||
|
||
// 打印移动之后的数组
|
||
printf("移动之后的数组：");
|
||
for (int i = 0; i < length; i++) {
|
||
printf("%d ", arr[i]);
|
||
}
|
||
printf("\n");
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 2.7.7 应用示例
|
||
|
||
* 需求：实现冒泡排序，即将数组的元素从小到大排列。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 思路：一层循环，能实现最大值移动到数组的最后；那么，二层循环（控制内部循环数组的长度）就能实现将数组的元素从小到大排序。
|
||
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 原始数组
|
||
int arr[] = {12, 2, 31, -24, 15, -36, 67, 891, 29, 51};
|
||
|
||
// 计算数组的长度
|
||
size_t length = sizeof(arr) / sizeof(arr[0]);
|
||
|
||
// 打印原始数组中的全部元素
|
||
printf("原始数组：");
|
||
for (int i = 0; i < length; i++) {
|
||
printf("%d ", arr[i]);
|
||
}
|
||
printf("\n");
|
||
|
||
for (int j = 0; j < length - 1; j++) {
|
||
for (int i = 0; i < length - 1 - j; i++) {
|
||
if (arr[i] > arr[i + 1]) {
|
||
int temp = arr[i];
|
||
arr[i] = arr[i + 1];
|
||
arr[i + 1] = temp;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 打印移动之后的数组
|
||
printf("移动之后的数组：");
|
||
for (int i = 0; i < length; i++) {
|
||
printf("%d ", arr[i]);
|
||
}
|
||
printf("\n");
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 2.7.8 应用示例
|
||
|
||
* 需求：数组中的元素是从小到大排列的，现在要求根据指定的元素获取其在数组中的位置。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 二分查找（折半查找）的前提条件是：数组中的元素必须是`有序`的（从小到大或从大到小）。其基本步骤，如下所示：
|
||
>
|
||
> * ① 确定初始范围：定义数组的起始索引 `min = 0` 和结束索引 `max = len - 1` 。
|
||
> * ② 计算中间索引：在每次迭代中，计算中间位置 `mid = (min + right) / 2`。
|
||
> * ③ 比较中间值：
|
||
> * 如果`目标值`比 `arr[mid]` 小，则继续在`左`半部分查找，那么 `min` 不变，而`max = mid - 1` 。
|
||
> * 如果`目标值`比 `arr[mid]` 大，则继续在`右`半部分查找，那么 `max` 不变，而`min = mid + 1` 。
|
||
> * 如果`目标值`和 `arr[mid]` 相等，则找到了目标，返回该索引。
|
||
> * ④ 结束条件：当 `min > max` 的时候，表示查找范围为空，即：元素不存在，返回 `-1`。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
/**
|
||
* 二分查找
|
||
*
|
||
* @param arr 数组
|
||
* @param len 数组长度
|
||
* @param num 要查找的数据
|
||
* @return 返回数据的下标，没有找到返回-1
|
||
*/
|
||
int search(int arr[], int len, int num) {
|
||
int min = 0;
|
||
int max = len - 1;
|
||
while (min <= max) {
|
||
int mid = (min + max) / 2;
|
||
if (num < arr[mid]) { // 说明要查找的数据在左半边
|
||
max = mid - 1;
|
||
} else if (num > arr[mid]) { // 说明要查找的数据在右半边
|
||
min = mid + 1;
|
||
} else { // 说明找到了
|
||
return mid;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
int main() {
|
||
|
||
int arr[] = {1, 2, 3, 4, 5, 6};
|
||
|
||
int len = sizeof(arr) / sizeof(arr[0]);
|
||
|
||
int index = search(arr, len, -1);
|
||
|
||
printf("index = %d\n", index);
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
# 第三章：多维数组（⭐）
|
||
|
||
## 3.1 概述
|
||
|
||
### 3.1.1 引入
|
||
|
||
* 我们在数学、物理和计算机科学等学科中学习过`一维坐标`、`二维坐标`以及`三维坐标`。
|
||
|
||
* 其中，`一维坐标`通常用于描述在线段或直线上的点的位置，主要应用有：
|
||
|
||
* **数轴**：一维坐标可以用来表示数轴上的数值位置，这在基础数学和初等代数中非常常见。
|
||
|
||
|
||
|
||
* **时间轴**：时间可以看作是一维的，它可以用一维坐标表示，例如：秒、分钟、小时等。
|
||
|
||
|
||
|
||
* **统计数据**：一维坐标常用于表示单变量的数据集，如：测量身高、体重、温度等。
|
||
|
||
|
||
|
||
* 其中，`二维坐标`用于描述平面上的点的位置。主要应用包括：
|
||
|
||
* **几何学**：在几何学中，二维坐标用于表示平面图形的顶点、边和面积等。
|
||
|
||
|
||
|
||
* **地图和导航**：地理坐标系统（经纬度）使用二维坐标来表示地球表面的任意位置。
|
||
|
||
|
||
|
||
* **图形设计和计算机图形学**：二维坐标在绘制图形、设计图案和用户界面中非常重要。
|
||
|
||
|
||
|
||
* **物理学**：二维运动和场，例如：在描述物体在平面上的运动轨迹时使用二维坐标。
|
||
|
||
|
||
|
||
* 其中，三维坐标用于描述空间中点的位置。主要应用包括：
|
||
|
||
* **几何学**：三维坐标在空间几何中用于表示立体图形的顶点、边、面和体积。
|
||
|
||
|
||
|
||
* **计算机图形学**：三维建模和动画需要使用三维坐标来创建和操控虚拟对象。
|
||
|
||
|
||
|
||
* **工程和建筑设计**：在设计建筑物、机械部件和其他工程项目时，使用三维坐标来精确定位和规划。
|
||
|
||
|
||
|
||
* **物理学**：三维空间中的力、运动和场，例如：描述物体在空间中的位置和运动轨迹。
|
||
|
||
|
||
|
||
* 总而言之，一维、二维和三维坐标系统在不同的领域中各有其重要的应用，从基础数学到高级科学和工程技术，它们帮助我们更好地理解和描述世界的结构和行为。
|
||
|
||
### 3.1.2 多维数组
|
||
|
||
* 在 C 语言中，多维数组就是数组嵌套，即：在数组中包含数组，数组中的每一个元素还是一个数组类型，如下所示：
|
||
|
||
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 如果数组中嵌套的每一个元素是一个常量值，那么该数组就是一维数组。
|
||
> * ② 如果数组中嵌套的每一个元素是一个一维数组，那么该数组就是二维数组。
|
||
> * ③ 如果数组中嵌套的每一个元素是一个二维数组，那么该数组就是三维数组.
|
||
> * ④ 依次类推...
|
||
|
||
* 一维数组和多维数组的理解：
|
||
* 从内存角度看：一维数组或多维数组都是占用的一整块连续的内存空间。
|
||
* 从数据操作角度看：
|
||
* 一维数组可以直接通过`下标`访问到数组中的某个元素，即：0、1、...
|
||
* 二维数组要想访问某个元素，先要获取某个一维数组，然后在一维数组中获取对应的数据。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① C 语言中的一维数组或多维数组都是占用的一整块连续的内存空间，其它编程语言可不是这样的，如：Java 等。
|
||
> * ② 在实际开发中，最为常用的就是二维数组或三维数组了，以二维数组居多！！！
|
||
|
||
## 3.2 二维数组的定义
|
||
|
||
### 3.2.1 动态初始化
|
||
|
||
* 语法：
|
||
|
||
```c
|
||
数据类型 数组名[几个⼀维数组元素][每个⼀维数组中有几个具体的数据元素];
|
||
```
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 二维数组在实际开发中，最为常见的应用场景就是表格或矩阵了。
|
||
> * ② 几个一维数组元素 = 行数。
|
||
> * ③ 每个⼀维数组中有几个具体的数据元素 = 列数。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义二维数组并初始化
|
||
int arr[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
|
||
|
||
// 输出二维数组中的元素
|
||
printf("%d ", arr[0][0]);
|
||
printf("%d ", arr[0][1]);
|
||
printf("%d ", arr[0][2]);
|
||
printf("%d \n", arr[0][3]);
|
||
printf("%d ", arr[1][0]);
|
||
printf("%d ", arr[1][1]);
|
||
printf("%d ", arr[1][2]);
|
||
printf("%d \n", arr[1][3]);
|
||
printf("%d ", arr[2][0]);
|
||
printf("%d ", arr[2][1]);
|
||
printf("%d ", arr[2][2]);
|
||
printf("%d ", arr[2][3]);
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 3.2.2 静态初始化 1
|
||
|
||
* 语法：
|
||
|
||
```c
|
||
数据类型 数组名[行数][列数] = {{元素1,元素2,...},{元素3,...},...}
|
||
```
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 行数 = 几个一维数组元素。
|
||
> * ② 列数 = 每个⼀维数组中有几个具体的数据元素。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义二维数组并初始化
|
||
int arr[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
|
||
|
||
// 输出二维数组中的元素
|
||
printf("%d ", arr[0][0]);
|
||
printf("%d ", arr[0][1]);
|
||
printf("%d ", arr[0][2]);
|
||
printf("%d \n", arr[0][3]);
|
||
printf("%d ", arr[1][0]);
|
||
printf("%d ", arr[1][1]);
|
||
printf("%d ", arr[1][2]);
|
||
printf("%d \n", arr[1][3]);
|
||
printf("%d ", arr[2][0]);
|
||
printf("%d ", arr[2][1]);
|
||
printf("%d ", arr[2][2]);
|
||
printf("%d ", arr[2][3]);
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 3.2.3 静态初始化 2
|
||
|
||
* 语法：
|
||
|
||
```c
|
||
数据类型 数组名[][列数] = {{元素1,元素2,...},{元素3,...},...}
|
||
```
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 列数 = 每个⼀维数组中有几个具体的数据元素。
|
||
> * ② 可以`不`指定`行数`，`必须`指定`列`数，编译器会根据元素的个数和列的个数，自动推断出行数！！！
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义二维数组
|
||
int arr[][4] = {{1, 2, 3, 4}, {5, 6}, {9, 10, 11, 12}};
|
||
|
||
// 输出二维数组中的元素
|
||
printf("%d ", arr[0][0]);
|
||
printf("%d ", arr[0][1]);
|
||
printf("%d ", arr[0][2]);
|
||
printf("%d \n", arr[0][3]);
|
||
printf("%d ", arr[1][0]);
|
||
printf("%d \n", arr[1][1]);
|
||
printf("%d ", arr[2][0]);
|
||
printf("%d ", arr[2][1]);
|
||
printf("%d ", arr[2][2]);
|
||
printf("%d ", arr[2][3]);
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
## 3.3 二维数组的理解
|
||
|
||
* 如果二维数组是这么定义的，即：
|
||
|
||
```c
|
||
int arr[3][4];
|
||
```
|
||
|
||
* 那么，这个二维数组 `arr` 可以看做是 `3` 个一维数组组成，它们分别是 `arr[0]`、`arr[1]`、`arr[2]`。这 `3` 个一维数组都各有 4 个元素，如：一维数组 `arr[0]` 中的元素是 `arr[0][0]`、`arr[0][1]`、`arr[0][2]`、`arr[0][3]`，即：
|
||
|
||
|
||
|
||
## 3.4 二维数组的遍历
|
||
|
||
* 访问二维数组的元素，需要使用两个下标（索引），一个用于访问行（第一维），另一个用于访问列（第二维），我们通常称为行下标（行索引）或列下标（列索引）。
|
||
* 所以，遍历二维数组，需要使用双层循环结构。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 如果一个二维数组是这么定义的，即：`int arr[3][4]`，那么：
|
||
>
|
||
> * `行的长度 = sizeof(arr) / sizeof(arr[0])` ，因为 `arr` 是二维数组的`总`的内存空间；而 `arr[0]` 、`arr[1]`、`arr[2]` 是二维数组中一维数组的内存空间 。
|
||
> * `列的长度 = sizeof(arr[0]) / sizeof(arr[0][0])`，因为`arr[0]` 、`arr[1]`、`arr[2]` 是二维数组中一维数组的内存空间 ，而 `arr[0][0]`、`arr[0][1]`、... 是一维数组中元素的内存空间。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义二维数组
|
||
int arr[][4] = {{1, 2, 3, 4}, {5, 6}, {9, 10, 11, 12}};
|
||
|
||
// 获取行列数
|
||
int row = sizeof(arr) / sizeof(arr[0]);
|
||
int col = sizeof(arr[0]) / sizeof(arr[0][0]);
|
||
|
||
// 打印二维数组元素
|
||
for (int i = 0; i < row; i++) {
|
||
for (int j = 0; j < col; j++) {
|
||
printf("%d ", arr[i][j]);
|
||
}
|
||
printf("\n");
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
## 3.5 二维数组的内存分析
|
||
|
||
* 用`矩阵形式`（如：3 行 4 列形式）表示二维数组，是`逻辑`上的概念，能形象地表示出行列关系。而在`内存`中，各元素是连续存放的，不是二维的，是`线性`的。
|
||
|
||
* C 语言中，二维数组中元素排列的顺序是`按行存放`的。即：先顺序存放第一行的元素，再存放第二行的元素。例如：数组`a[3][4] `在内存中的存放，如下所示：
|
||
|
||
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 这就是 `C` 语言的二维数组在进行静态初始化的时候，`可以`忽略`行数`的原因所在（底层的`内存结构`是`线性`的），因为可以根据 `元素的总数 ÷ 每列元素的个数 = 行数`的公式计算出`行数`。
|
||
> * ② 如果你学过 `Java` 语言，可能会感觉困惑，Java 语言中的二维数组在进行静态初始化，是`不能`忽略`行数`的，是因为 Java 编译器会根据`行数`去堆内存空间先开辟出一维数组，然后再继续...，所以当然`不能`忽略`行数`。
|
||
|
||
## 3.6 二维数组的应用案例
|
||
|
||
* 需求：现在有三个班，每个班五名同学，用二维数组保存他们的成绩，并求出每个班级平均分、以及所有班级平均分，数据要求从控制台输入。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义二维数组，用于保存成绩
|
||
double arr[3][5];
|
||
|
||
// 获取二维数组的行数和列数
|
||
int row = sizeof(arr) / sizeof(arr[0]);
|
||
int col = sizeof(arr[0]) / sizeof(arr[0][0]);
|
||
|
||
// 从控制台输入成绩
|
||
for (int i = 0; i < row; i++) {
|
||
for (int j = 0; j < col; j++) {
|
||
printf("请输入第%d个班级的第%d个学生的成绩：", i + 1, j + 1);
|
||
scanf("%lf", &arr[i][j]);
|
||
}
|
||
}
|
||
|
||
// 总分
|
||
double totalSum = 0;
|
||
|
||
// 遍历数组，求总分和各个班级的平均分
|
||
for (int i = 0; i < row; i++) {
|
||
double sum = 0;
|
||
for (int j = 0; j < col; j++) {
|
||
totalSum += arr[i][j];
|
||
sum += arr[i][j];
|
||
}
|
||
printf("第%d个班级的总分为：%.2lf\n", i + 1, sum);
|
||
printf("第%d个班级的平均分为：%.2lf\n", i + 1, sum / col);
|
||
}
|
||
|
||
printf("所有班级的总分为：%.2lf\n", totalSum);
|
||
printf("所有班级的平均分为：%.2lf\n", totalSum / (row * col));
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
# 第四章：字符串（⭐）
|
||
|
||
## 4.1 概述
|
||
|
||
* 在实际开发中，我们除了经常处理整数、浮点数、字符等，还经常和字符串打交道，如：`"Hello World"`、`"Hi"` 等。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 像这类`"Hello World"`、`"Hi"`等格式 ，使用`双引号`引起来的一串字符称为字符串字面值，简称字符串。
|
||
|
||
* 对于整数、浮点数和字符，C 语言中都提供了对应的数据类型。但是，对于字符串，C 语言并没有提供对应的数据类型，而是用`字符数组`来存储这类文本类型的数据，即字符串：
|
||
|
||
```c
|
||
char str[32];
|
||
```
|
||
|
||
* 字符串不像整数、浮点数以及字符那样有固定的大小，字符串是不定长的，如：`"Hello World"`、`"Hi"` 等的长度就是不一样的。在 C 语言中，规定了字符串的结尾必须是 `'\0'` ，这种字符串也被称为 `C 风格的字符串`，如：
|
||
|
||
```c
|
||
"Hello World!" // 在 C 语言中，底层存储就是 Hello World!\0
|
||
```
|
||
|
||
* 其对应的图示，如下所示：
|
||
|
||
|
||
|
||
* `'\0'` 在 ASCII 码表中是第 `0` 个字符，用 `NUL` 表示，称为空字符，该字符既不能显示，也不是控制字符，输出该字符不会有任何效果，它在 C 语言中仅作为字符串的结束标志。
|
||
* C 语言在处理字符串时，会从前往后逐个扫描字符，一旦遇到`'\0'`就认为到达了字符串的末尾，就结束处理。`'\0'`至关重要，没有`'\0'`就意味着永远也到达不了字符串的结尾。
|
||
|
||
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 在现代化的高级编程语言中，都提供了字符串对应的类型，如：Java 中的 String（JDK 11 之前，底层也是通过 `char[]` 数组来实现的） 。
|
||
|
||
## 4.2 字符数组（字符串）的定义
|
||
|
||
### 4.2.1 标准写法
|
||
|
||
* 手动在字符串的结尾添加 `'\0'`作为字符串的结束标识。
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
// 禁用 stdout 缓冲区
|
||
setbuf(stdout, NULL);
|
||
|
||
// 字符数组，不是字符串
|
||
char c1[] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'};
|
||
// C 风格的字符串
|
||
char c2[] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '\0'};
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 4.2.2 简化写法（推荐）
|
||
|
||
* 字符串写成数组的形式，非常麻烦。C 语言中提供了一种简化写法，即：双引号中的字符，会自动视为字符数组。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 简化写法会自动在末尾添加 `'\0'` 字符，强烈推荐使用！！！
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
// 禁用 stdout 缓冲区
|
||
setbuf(stdout, NULL);
|
||
|
||
char c1[] = {"Hello World"}; // 注意使用双引号，非单引号
|
||
char c2[] = "Hello World"; // //可以省略一对 {} 来初始化数组元素
|
||
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
## 4.3 字符串的输入和输出
|
||
|
||
### 4.3.1 字符串的输出
|
||
|
||
* 在 C 语言中，有两个函数可以在控制台上输出字符串，它们分别是：
|
||
* ① `puts()`：输出字符串并自动换行，并且该函数只能输出字符串。
|
||
* ② `printf()` ：通过格式占位符 `%s`，就可以输出字符串，不能自动换行。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① `printf()` 函数除了输出字符串之外，还可以输出`其它类型`的数据。
|
||
> * ② 在实际开发中，`printf()` 函数用的居多！！！
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
// 禁用 stdout 缓冲区
|
||
setbuf(stdout, NULL);
|
||
|
||
char c1[] = {"Hello World"}; // 注意使用双引号，非单引号
|
||
char c2[] = "Hello World"; // //可以省略一对 {} 来初始化数组元素
|
||
|
||
puts(c1); // Hello World
|
||
puts(c2); // Hello World
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
// 禁用 stdout 缓冲区
|
||
setbuf(stdout, NULL);
|
||
|
||
char c1[] = {"Hello World"}; // 注意使用双引号，非单引号
|
||
char c2[] = "Hello World"; // //可以省略一对 {} 来初始化数组元素
|
||
|
||
printf("c1 = %s\n", c1); // c1 = Hello World
|
||
printf("c2 = %s\n", c2); // c2 = Hello World
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 4.3.2 字符串的输入
|
||
|
||
* 在 C 语言中，有两个函数可以让用户从键盘输入字符串，它们分别是：
|
||
* ① ~~`gets()`：直接输入字符串，并且只能输入字符串~~。
|
||
* ② `scanf()`：通过格式占位符 `%s`，就可以输入字符串了。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① `scanf()` 在通过格式占位符 `%s`，读取字符串时以`空格`或 `Enter` 键为分隔，遇到`空格`或 `Enter` 键就认为当前字符串结束了，所以无法读取含有空格的字符串。但是，我们可以将格式占位符，使用 `%[^\n]`来代替 `%s` ，这样就能解决 `scanf()` 函数默认的缺陷。
|
||
> * ② `gets()` 认为空格也是字符串的一部分，只有遇到回车键时才认为字符串输入结束。换言之，不管输入了多少个空格，只要不按下回车键，对 `gets()` 来说就是一个完整的字符串。
|
||
> * ③ 需要注意的是，`gets()` 函数在 [C11](https://zh.cppreference.com/w/c/11) 标准中，已经被移除了，推荐使用 `fgets` 来代替它，因为有严重的安全漏洞，即：`gets()` 函数读取用户输入直到换行符，但它不会检查缓冲区的大小。这意味着如果用户输入超过了缓冲区的大小，`gets()` 将会导致缓冲区溢出。这种缓冲区溢出很容易被恶意利用，导致程序崩溃或执行恶意代码。
|
||
|
||
* 示例：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
// 禁用 stdout 缓冲区
|
||
setbuf(stdout, NULL);
|
||
|
||
char str[32] = {'\0'};
|
||
|
||
printf("请输入字符串：");
|
||
gets(str);
|
||
|
||
printf("字符串是：%s\n", str);
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c {13}
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
// 禁用 stdout 缓冲区
|
||
setbuf(stdout, NULL);
|
||
|
||
char str[32] = {'\0'};
|
||
|
||
printf("请输入字符串：");
|
||
// scanf() 在读取数据时需要的是数据的地址，这一点是恒定不变的。
|
||
// 对于 int、char、float 等类型的变量都要在前边添加 & 以获取它们的地址。
|
||
// 而数组或者字符串用于 scanf() 时不用添加 &，它们本身就会转换为地址。
|
||
scanf("%[^\n]", str);
|
||
|
||
printf("字符串是：%s\n", str);
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
## 4.4 字符串结束不是 `'\0'` 的后果
|
||
|
||
* 有的时候，程序的逻辑要求我们必须逐个字符为数组赋值，这个时候就很容易遗忘字符串结束标识 `'\0'`，如下所示：
|
||
|
||
```c {3}
|
||
#include <stdio.h>
|
||
int main() {
|
||
char str[30];
|
||
char c;
|
||
int i;
|
||
for (c = 65, i = 0; c <= 90; c++, i++) {
|
||
str[i] = c;
|
||
}
|
||
printf("%s\n", str);
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
* 该程序的执行结果，如下所示：
|
||
|
||
|
||
|
||
* 因为`大写字符`在 `ASCII` 码表是连续的，编码值从 `65` 开始，直到 `90` 结束；并且，为了方便，我们使用了循环。但是，我们却发现结果和我们想要的大不一样，为什么？
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 在函数内部定义的变量、数组、结构体、共用体等都称为局部数据。
|
||
>
|
||
> * ② 在很多编译器下，局部数据的初始值都是随机的、无意义的，而不是我们通常认为的“零”值。
|
||
|
||
* 我们在定义 `str` 数组的时候，并没有立即初始化，所以它包含的值都是随机的，只有很小的概率是“零”。循环结束后，`str` 的前 `26` 个元素被赋值了，剩下的 `4` 个元素的值依然是随机的，我们并不清楚到底是什么。
|
||
* `printf()` 输出字符串时，会从第 `0` 个元素开始往后检索，直到遇见`'\0'`才停止，然后把`'\0'`前面的字符全部输出，这就是 `printf()` 输出字符串的原理。
|
||
* 但是，对于上面的例子，由于我们并没有对最后 `4` 个元素赋值，所以第 `26` 元素可能是 `'\0'`，也有可能第 `27` 个元素是 `'\0'`，也有可能第 `28` 个元素是 `'\0'`；不过，不要问`我`，`我`也不清楚，可能只有`上帝`才会知道，到底第`几`个元素才是 `'\0'`。而且，我们在定义数组的时候，设置数组的长度是 `30` ，但是貌似输出的字符串的长度是 `32` ，这早已超出了数组的范围，`printf()` 在输出字符串的时候，如果没有遇见 `'\0'` 是不会罢休的，它才不会管`数组访问`是不是`越界`。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 由此可见，不注意`'\0'`的后果有多严重，不但不能正确处理字符串，甚至还会毁坏其它数据！！！
|
||
> * ② C 语言为了提高效率，保证操作的灵活性，并不会对越界行为进行检查，即使越界了，也能够正常编译，只有在运行期间才可能发现问题，所以对程序员的要求很高。但是，现代化的高级编程语言，如：Java 等，为了降低开发难度以及提高开发效率，像数组这种越界行为，在编译期间就会由编译器提前捕获，并直接报错！！！
|
||
|
||
* 如果要避免这些问题也很简单，在字符串后面手动添加 `'\0'` 就可以了，即：
|
||
|
||
```c {9}
|
||
#include <stdio.h>
|
||
int main() {
|
||
char str[30];
|
||
char c;
|
||
int i;
|
||
for (c = 65, i = 0; c <= 90; c++, i++) {
|
||
str[i] = c;
|
||
}
|
||
str[i] = '\0';
|
||
printf("%s\n", str);
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
* 但是，上述的写法实在麻烦，为什么不在定义数组的时候，给数组中的每个元素都初始化，这样才能从根本上避免上述问题，即：
|
||
|
||
```c {3}
|
||
#include <stdio.h>
|
||
int main() {
|
||
char str[30] = {'\0'};
|
||
char c;
|
||
int i;
|
||
for (c = 65, i = 0; c <= 90; c++, i++) {
|
||
str[i] = c;
|
||
}
|
||
printf("%s\n", str);
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
## 4.5 字符串的长度
|
||
|
||
* 所谓字符串的长度，就是字符串包含了多少个字符（不包括最后的结束符`'\0'`），如：`"abc"` 的长度是 `3` ，而不是 `4` 。
|
||
* 在 C 语言中的 `string.h` 中提供了 `strlen()` 函数，能够帮助我们获取字符串的长度，如下所示：
|
||
|
||
```c
|
||
size_t strlen (const char *__s)
|
||
```
|
||
|
||
|
||
|
||
* 示例：
|
||
|
||
```c {13}
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
int main() {
|
||
char str[30] = {'\0'};
|
||
char c;
|
||
int i;
|
||
for (c = 65, i = 0; c <= 90; c++, i++) {
|
||
str[i] = c;
|
||
}
|
||
// ABCDEFGHIJKLMNOPQRSTUVWXYZ
|
||
printf("%s\n", str);
|
||
// ABCDEFGHIJKLMNOPQRSTUVWXYZ 的长度是 26
|
||
printf("%s 的长度是 %zu\n", str, strlen(str));
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
# 第五章：内存中的变量和数组（⭐）
|
||
|
||
## 5.1 内存和内存地址
|
||
|
||
### 5.1.1 内存
|
||
|
||
* `内存`是一种`计算机硬件`，是`软件`在`运行过程`中，用来`临时存储数据`的。在生活中，最为常见的`内存`就是`随机存取存储器（RAM，内存条`），其特点如下所示：
|
||
* ① 生活中最常见的内存类型，用于存储当前运行的程序和数据。
|
||
* ② 内存是易失性存储器，这意味着断电后数据会丢失。
|
||
* ③ 它具有高速读写特性，适用于需要快速访问的操作。
|
||
|
||
* 内存条的外观，如下所示：
|
||
|
||
|
||
|
||
* 像我们平常使用`记事本`软件一样，当我们输入一些文字的时候，其实是将数据`临时`保存在内存中的，如下所示：
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 目前，很多软件都很智能，如果用户没有将数据到保存文件中，将显示红色，以警告用户还没有保存数据，提醒用户需要尽快保存数据！！！
|
||
> * ② 但是，也有很多软件提供了自动保存数据的功能，其原理就是定时（1s、3s、5s）将内存中的数据刷新到文件中，以防止数据丢失！！！
|
||
> * ③ 将数据从内存存储到文件中，专业的说法是落盘（落在磁盘上）。
|
||
|
||
|
||
|
||
* 此时，如果我们在没有保存的过程下，将`记事本`软件关闭，那么刚才输入的文字将丢失；下次，再打开同样的文件（将数据从磁盘加载进内存，再交给 CPU），之前输入的文字将不复存在，如下所示：
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 目前，很多软件都很智能，如果你没有保存，将提醒你是否保存或丢失刚才输入的文字。
|
||
> * ② 但是，也有很多软件提供了自动保存数据的功能，其原理就是定时（1s、3s、5s）将内存中的数据刷新到文件中，以防止数据丢失！！！
|
||
> * ③ 将数据从内存存储到文件中，专业的说法是落盘（落在磁盘上）。
|
||
|
||
|
||
|
||
> [!IMPORTANT]
|
||
>
|
||
> 内存就是软件在运行过程中，用来临时存储数据的，最为重要的两个步骤就是：
|
||
>
|
||
> * ① 将数据`保存`到内存中。
|
||
> * ② 从内存中的`对应位置`将数据`取出来`。
|
||
|
||
### 5.1.2 内存地址
|
||
|
||
* 在这个计算机的内存条，动不动就 32GB、64GB 、128GB 或更高的年代，如下所示：
|
||
|
||
|
||
|
||
* 如果有一个 int （4 个字节）类型的数据 `2` ，如何将这个数据保存到内存中？（对应上述的步骤 ①）
|
||
|
||
|
||
|
||
* 就算数据 `2` 已经保存到内存中，那么内存中那么多的数据，我们又该如何取出呢？（对应上述的步骤 ②）
|
||
|
||
|
||
|
||
> [!IMPORTANT]
|
||
>
|
||
> 答案就是`内存地址`。
|
||
|
||
* 操作系统为了更快的去管理内存中的数据，会将`内存条`按照`字节`划分为一个个的`单元格`，如下所示：
|
||
|
||
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 计算机中存储单位的换算，如下所示：
|
||
>
|
||
> - 1 B = 8 bit。
|
||
> - 1 KB = 1024 B。
|
||
> - 1 MB = 1024 KB。
|
||
> - 1 GB = 1024 MB。
|
||
> - 1 TB = 1024 GB 。
|
||
> - ……
|
||
|
||
* 为了方便管理，每个独立的小单元格，都有自己唯一的编号（内存地址），如下所示：
|
||
|
||
|
||
|
||
* 之所以，加了`内存地址`，就能`加快`数据的存取速度，可以类比生活中的`字典`：
|
||
|
||
* 如果没有使用`拼音查找法`或`部首查找法`，我们需要一页一页，一行一行的，在整个字典中去搜索我们想要了解的汉字，效率非常低（如果要搜索的汉字在最后一页，可能需要将整个字典从头到尾翻一遍，这辈子真有可能翻得完？）。
|
||
|
||
|
||
|
||
* 如果使用`拼音查找法`或`部首查找法`，我们可以很快的定位到所要了解汉字所在的页数，加快了搜索的效率。
|
||
|
||
|
||
|
||
|
||
|
||
* 同样的道理，如果`没有`内存地址，我们只能一个个的去寻找想要的数据，效率非常低下，如下所示：
|
||
|
||
|
||
|
||
* 如果`使用`内存地址，我们就可以直接定位到指定的数据，效率非常高，如下所示：
|
||
|
||
|
||
|
||
> [!IMPORTANT]
|
||
>
|
||
> * ① 内存地址是计算机中用于标识内存中某个特定位置的数值。
|
||
> * ② 每个内存单元都有一个唯一的地址，这些地址可以用于访问和操作存储在内存中的数据。
|
||
|
||
|
||
|
||
* 实际中的内存地址，并不是像上面的 `001` 、`002` 、... 之类的数字，而是有自己的规则，即：内存地址规则。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 32 位的操作系统中，内存地址以 32 位的二进制表示。
|
||
> * ② 64 位的操作系统中，内存地址以 64 位的二进制表示。
|
||
|
||
* 在 32 位的操作系统中，内存地址的范围是：`0000 0000 0000 0000 0000 0000 0000 0000` ~ `1111 1111 1111 1111 1111 1111 1111 1111` （2 ^ 32 次方）。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 在 32 位的操作系统中，一共有 4,294,967,296 个内存地址，其最大支持的内存大小是 4,294,967,296 字节，即 4 GB 。
|
||
|
||
* 在 64 位的操作系统中，内存地址的范围是：`0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000` ~ `1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111` （2 ^ 64 次方）。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 在 64 位的操作系统中，一共有 18,446,744,073,709,551,616 个内存地址，其最大支持的内存大小是 18,446,744,073,709,551,616 字节，即 17,179 TB 。
|
||
> * ② 虽然，从理论上 64 位的操作系统支持的内存最大容量是 17,179 TB；但是，实际操作系统会有所限制，如：win11 的 64 位支持的最大内存是 128 GB ~ 6 TB，Linux 64 位支持的最大内存通常是 256 TB。
|
||
|
||
* 在实际开发中，64 位操作系统的内存地址表现形式，如：`0000 0000 0000 0000 0001 0000 1111 1010 0000 0000 0010 0000 0000 0010 0000 1000`，实在是太长了，我们通常转换为十六进制，以方便阅读，如：`0x000010FA00200208` 。
|
||
|
||
> [!IMPORTANT]
|
||
>
|
||
> * ① 内存地址是内存中每个单元的编号。
|
||
>* ② 内存地址的作用是操作系统用来快速管理内存空间的。
|
||
> * ③ 在 32 位操作系统上，内存地址以 32 位的二进制数字表示，最大支持的的内存是 4 GB，所以 32 位操作系统已经被淘汰。
|
||
> * ④ 在 64 位操作系统上，内存地址以 64 位的二进制数字表示，由于表示形式太长，我们通常会转为十六进制，以方便阅读。
|
||
|
||
## 5.2 内存中的变量
|
||
|
||
* 在 C 语言中，数据类型的种类很多，如：short、int、long、float、double、char 等。以 int 类型为例，在 32 位或 64 位操作系统中的，int 类型的变量都是占 4 个字节，当我们在代码中这么定义变量，如：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main(){
|
||
|
||
// 定义一个变量并初始化
|
||
int a = 10;
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
* 那么，编译器就会这么处理，如下所示：
|
||
|
||
|
||
|
||
* 在代码中，我们可以使用 `&变量名` 来获取一个变量的内存首地址，如下所示：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义一个变量并初始化
|
||
int a = 10;
|
||
|
||
printf("变量 a 的首地址是: %p\n", &a); // 变量 a 的首地址是: 0000002bf1dffd0c
|
||
printf("变量 a 的中保存的值是: %d\n", a); // 变量 a 的中保存的值是: 10
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① `变量`是对程序中`数据`在内存中存储空间的抽象，如果不涉及到指针变量，那我们在编码的时候，就只需要将变量等价于内存中存储空间里面存储的数据，而不需要再去考虑编译器底层是如何转换，提高了开发效率（机器语言和汇编可不是这样的，需要关注每个细节）。
|
||
> * ② 数据类型只在`定义`变量的时候`指定`，而且必须指定；`使用`变量的时候`无需`再声明，因为此时的数据类型已经确定了。
|
||
|
||
## 5.3 内存中的数组
|
||
|
||
* 如果我们在代码中这么定义数组，如下所示：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main(){
|
||
|
||
// 定义一个数组并初始化
|
||
int arr[] = {1,2,3};
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
* 那么，编译器就会这么处理，如下所示：
|
||
|
||
|
||
|
||
* 在代码中，我们可以直接打印数组名的内存地址，如下所示：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
int arr[] = {1, 2, 3};
|
||
|
||
printf("arr 的首地址是: %p \n", arr); // arr 的首地址是: 0000003a6f7ffcd4
|
||
printf("arr 的首地址是: %p \n", &arr); // &arr 的地址是: 0000003a6f7ffcd4
|
||
printf("arr[0] 的地址是: %p \n", &arr[0]); // arr[0] 的地址是: 0000003a6f7ffcd4
|
||
printf("arr[1] 的地址是: %p \n", &arr[1]); // arr[1] 的地址是: 0000003a6f7ffcd8
|
||
printf("arr[2] 的地址是: %p \n", &arr[2]); // arr[2] 的地址是: 0000003a6f7ffcdc
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
> [!WARNING]
|
||
>
|
||
> 在上述示例中，`arr` 和 `&arr` 的值是一样的，但是对应的含义是不同的。
|
||
>
|
||
> * ① `arr` 是数组名，在大多数情况下会转换为数组第一个元素的地址，即：`arr` 等价于 `&arr[0]`，其数据类型是 `int *`。
|
||
> * ② `&arr`是数组名的地址，即整个数组的地址，它指向数组本身，并不是数组第一个元素的地址，`&arr` 的数据类型是 `int(*)[3]`。
|
||
|
||
|
||
|
||
# 第六章：数组越界和数组溢出（⭐）
|
||
|
||
## 6.1 数组越界
|
||
|
||
* C 语言的数组是静态的，当我们定义的时候，就不能自动扩容。当我们试图访问数组的`负索引`或`超出`数组长度的索引时，就会产生`数组越界`。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① C 语言为了提高效率，保证操作的灵活性，并不会对越界行为进行检查，即使越界了，也能够正常编译，只有在运行期间才可能发现问题，所以对程序员的要求很高。
|
||
> * ② 但是，现代化的高级编程语言，如：Java 等，为了降低开发难度以及提高开发效率，像数组这种越界行为，在编译期间就会由编译器提前捕获，并直接报错！！！
|
||
|
||
* 请看下面的代码：
|
||
|
||
```c {9-10,15}
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
// 禁用 stdout 缓冲区
|
||
setbuf(stdout, NULL);
|
||
|
||
int arr[3] = {10, 20, 30};
|
||
|
||
printf("arr[-1] = %d\n", arr[-1]); // arr[-1] = -23718968
|
||
printf("arr[-2] = %d\n", arr[-2]); // arr[-2] = 0
|
||
printf("arr[0] = %d\n", arr[0]); // arr[0] = 10
|
||
printf("arr[1] = %d\n", arr[1]); // arr[1] = 20
|
||
printf("arr[2] = %d\n", arr[2]); // arr[2] = 30
|
||
printf("arr[3] = %d\n", arr[3]); // arr[3] = -23718976
|
||
printf("arr[4] = %d\n", arr[4]); // arr[4] = 605
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
* 越界访问数组元素的值都是不确定的，没有实际的含义，因为在数组之外的内存，我们并不知道到底是什么，可能是其它变量的值，可能是函数参数，也可能是一个地址，这些都是不可控的。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> 由于 C 语言的”放任“，我们访问数组时必须非常小心，要确保不会发生越界。
|
||
|
||
* 当发生数组越界时，如果我们对该内存有使用权限，那么程序将正常运行，但会出现不可控的结果，即：如果我们对该内存没有使用权限，或者该内存压根就没有就分配，那么程序就会崩溃，如下所示：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
int arr[3] = {0};
|
||
printf("%d", arr[10000]);
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
* 其结果，如下所示：
|
||
|
||
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 每个程序能使用的内存都是有限的，该程序要访问 `4*10000` 字节处的内存，显然太远了，超出了程序的访问范围。
|
||
> * ② 这个地方的内存可能没有被分配，可能是系统本身占用的内存，可能是其它数据的内存，如果放任这种行为，将带来非常危险的后果，操作系统只能让程序停止运行。
|
||
|
||
* 当然，我们在实际开发中，也不会这么访问，而是会使用 `sizeof` 运算符来获取数组的长度，进而遍历数组中的元素，即：
|
||
|
||
```c {7}
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
int arr[3] = {0};
|
||
|
||
// 获取数组的元素
|
||
size_t length = sizeof(arr) / sizeof(int);
|
||
|
||
for (size_t i = 0; i < length; i++) {
|
||
printf("%d\n", arr[i]);
|
||
}
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
## 6.2 数组溢出
|
||
|
||
* 数组溢出通常是指将数据存储到一个数组中，超出了数组所能容纳的空间，那么多余的元素就会被丢弃。对于一般的数组，貌似没什么问题，如下所示：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
int arr[3] = {0, 1, 2, 3, 4};
|
||
|
||
size_t length = sizeof(arr) / sizeof(int);
|
||
|
||
for (size_t i = 0; i < length; i++) {
|
||
printf("%d\n", arr[i]);
|
||
}
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
* 其结果，如下所示：
|
||
|
||
|
||
|
||
* 但是，对于字符串而言，就会出现不可控的情况，如下所示：
|
||
|
||
```c {4}
|
||
#include <stdio.h>
|
||
int main()
|
||
{
|
||
char str[10] = "Hello World，Hello World，Hello World，";
|
||
puts(str);
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
* 其结果，如下所示：
|
||
|
||
|
||
|
||
* 因为字符串的长度大于数组的长度，数组只能容纳字符串前面的一部分，即使编译器在字符串最后保存了 `'\0'`，也无济于事，因为超过数组长度的元素都会被丢弃。而 `printf()` 输出字符串时，会从第 `0` 个元素开始往后检索，直到遇见`'\0'`才停止，然后把`'\0'`前面的字符全部输出，至于何时遇到 `'\0'`，就只有上帝才能知道。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 在用字符串给字符数组赋值时，要保证数组长度大于字符串长度，以容纳结束符`'\0'`。
|
||
> * ② `数组溢出`通常发生在动态分配内存或者通过不安全的函数（如： `strcpy`）进行字符串操作。
|
||
|
||
|
||
|
||
# 第七章：C 语言中的数组 VS Java 语言中的数组（⭐）
|
||
|
||
## 7.1 Linux 下 32 位环境的用户空间内存分布情况
|
||
|
||
* 对于 32 位的环境而言，理论上程序是可以拥有 4GB 的虚拟地址空间的，在 C 语言中使用到的变量、函数、字符串等都会对应内存中的一块区域。
|
||
* 但是，在这 4GB 的地址空间中，要拿出一部分给操作系统内核使用，应用程序无法直接访问这一段内存，这一部分内存地址被称为`内核空间`（Kernel Space）。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> - ① Windows 在默认情况下会将高地址的 2GB 空间分配给内核（也可以配置为 1GB）。
|
||
> - ② 而 Linux 默认情况下会将高地址的 1GB 空间分配给内核。
|
||
|
||
* 也就是说，应用程序只能使用剩下的 2GB 或 3GB 的地址空间，称为`用户空间`（User Space）。
|
||
* Linux 下 32 位环境的经典内存模型，如下所示：
|
||
|
||
|
||
|
||
* 各个内存分区的说明，如下所示：
|
||
|
||
| 内存分区 | 说明 |
|
||
| :------------------------ | :----------------------------------------------------------- |
|
||
| 程序代码区（code） | 存储程序的执行代码，通常为只读区，包含程序的指令。 程序启动时，这部分内存被加载到内存中，并不会在程序执行期间改变。 |
|
||
| 常量区（constant） | 存放程序中定义的常量值，通常也是只读的，这些常量在程序运行期间不可修改。 |
|
||
| 全局数据区（global data） | 存储程序中定义的全局变量和静态变量。 这些变量在程序的整个生命周期内存在，且可以被修改。 |
|
||
| 堆区（heap） | 用于动态分配内存，例如：通过 `malloc` 或 `new` 分配的内存块。 堆区的内存由程序员手动管理，负责分配和释放。 如果程序员不释放，程序运行结束时由操作系统回收。 |
|
||
| 动态链接库 | 动态链接库（如： `.dll` 或 `.so` 文件）被加载到内存中特定的区域，供程序运行时使用。 |
|
||
| 栈区（stack） | 用于存储函数调用的局部变量、函数参数和返回地址。 栈是自动管理的，随着函数的调用和返回，栈上的内存会自动分配和释放。 |
|
||
|
||
> [!NOTE]
|
||
>
|
||
> - ① 程序代码区、常量区、全局数据区在程序加载到内存后就分配好了，并且在程序运行期间一直存在，不能销毁也不能增加（大小已被固定），只能等到程序运行结束后由操作系统收回，所以全局变量、字符串常量等在程序的任何地方都能访问，因为它们的内存一直都在。
|
||
> - ② 函数被调用时，会将参数、局部变量、返回地址等与函数相关的信息压入栈中，函数执行结束后，这些信息都将被销毁。所以局部变量、参数只在当前函数中有效，不能传递到函数外部，因为它们的内存不在了。
|
||
> - ③ 常量区、全局数据区、栈上的内存由系统自动分配和释放，不能由程序员控制。程序员唯一能控制的内存区域就是`堆`（Heap）：它是一块巨大的内存空间，常常占据整个虚拟空间的绝大部分，在这片空间中，程序可以申请一块内存，并自由地使用（放入任何数据）。堆内存在程序主动释放之前会一直存在，不随函数的结束而失效。在函数内部产生的数据只要放到堆中，就可以在函数外部使用。
|
||
|
||
## 7.2 C 语言中的数组
|
||
|
||
* 之前，我们都是这么使用数组的，如下所示：
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
|
||
// 定义数组和全部初始化：数组初始化的元素个数等于数组的长度。
|
||
int arr[5] = {1, 2, 3, 4, 5};
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
* 其实，这样定义的数组是在`栈`中的，而栈的内存空间是有限的，如果数组中的元素过多，将会出现 `Stack Overflow` 的现象，即：栈溢出。
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 栈内存的大小和编译器有关，编译器会为栈内存制定一个最大值。
|
||
> * ② 在 VS 中，默认是 1 MB；在 GCC 下，默认是 8 MB。
|
||
> * ③ 虽然可以通过参数来修改栈内存的大小；但是，在实际开发中，我们一般也不会这么做。
|
||
|
||
* 所以，在实际开发中，如果我们要使用数组，就需要在`堆`中开辟内存空间，因为堆中的内存空间是可以动态扩容和缩容的，只不多在 C 语言中对于堆中申请的内存空间，需要程序员在用完之后，手动释放掉；否则，将会造成内存泄漏现象。
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
|
||
int main() {
|
||
int n; // 数组的大小
|
||
printf("请输入数组的大小: ");
|
||
scanf("%d", &n);
|
||
|
||
// 使用 malloc 申请内存，申请 n 个 int 类型的空间
|
||
int *array = (int *)malloc(n * sizeof(int));
|
||
|
||
// 检查 malloc 是否成功
|
||
if (array == NULL) {
|
||
printf("内存分配失败！\n");
|
||
return 1; // 程序退出
|
||
}
|
||
|
||
// 初始化数组并输出
|
||
for (int i = 0; i < n; i++) {
|
||
array[i] = i + 1; // 简单赋值操作
|
||
printf("array[%d] = %d\n", i, array[i]);
|
||
}
|
||
|
||
// 使用完毕后，释放内存
|
||
free(array);
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
## 7.3 Java 语言中的数组
|
||
|
||
* Java 语言和 C 语言不同，Java 语言从语法层面就将数组在内存中的分配放到了`堆`中。
|
||
|
||
```c
|
||
public class Test {
|
||
|
||
public static void main(String[] args){
|
||
// 在堆内存开辟数组，使用完毕后，不需要手动回收对应的内存空间
|
||
int[] arr = new int[4] ;
|
||
}
|
||
}
|
||
```
|
||
|
||
> [!NOTE]
|
||
>
|
||
> * ① 在 Java 语言中，数组的内存分配是由 JVM（Java Virtual Machine，Java 虚拟机）自动管理的，开发者不需要像在 C 语言中那样手动调用 `malloc` 来申请内存。Java 提供了更加高级的内存管理机制，所有数组在堆中动态分配。
|
||
> * ② 在 Java 中，声明和初始化数组的过程本质上就是在堆内存中分配数组内存的过程。每个数组在创建时都会被分配到堆中，并且由垃圾回收机制（Garbage Collector，GC）自动负责内存的回收。
|
||
> * ③ 我们甚至可以理解为：Java 语言是 C 语言在实际开发过程中的最佳实践版本。
|
||
|