C语言学习之路（基础篇）—— 函数

痛定思痛。 2024-04-01 16:51 85阅读 0赞

说明：该篇博客是博主一字一码编写的，实属不易，请尊重原创，谢谢大家！

## 概述 ##

### 1) 函数是什么 ###

函数就是一段封装好的，可以重复使用的代码，它使得我们的程序更加模块化，不需要编写大量重复的代码。

函数可以提前保存起来，并给它起一个独一无二的名字，只要知道它的名字就能使用这段代码。函数还可以接收数据，并根据数据的不同做出不同的操作，最后再把处理结果反馈给我们。

### 2) 函数的分类 ###

`C` 程序是由函数组成的，我们写的代码都是由主函数 `main()`开始执行的。函数是 `C` 程序的基本模块，是用于完成特定任务的程序代码单元。

从函数定义的角度看，函数可分为系统函数和用户定义函数两种：

*  **系统函数，即库函数：** 这是由编译系统提供的，用户不必自己定义这些函数，可以直接使用它们，如我们常用的打印函数`printf()`。
 *  **用户定义函数：** 用以解决用户的专门需要。

### 3) 函数的作用 ###

*  函数的使用可以省去重复代码的编写，降低代码重复率
 *  函数可以让程序更加模块化，从而有利于程序的阅读，修改和完善

这里我们可以这么理解，程序就像公司，公司是由部门组成的，这个部门就类似于C程序的函数。默认情况下，公司就是一个大部门( 只有一个部门的情况下 )，相当于`C`程序的`main()`函数。如果公司比较小( 程序比较小 )，因为任务少而简单，一个部门即可( `main()`函数 )胜任。但是，如果这个公司很大( 大型应用程序 )，任务多而杂，如果只是一个部门管理( 相当于没有部门，没有分工 )，我们可想而知，公司管理、运营起来会有多混乱，不是说这样不可以运营，只是这样不完美而已，如果根据公司要求分成一个个部门( 根据功能封装一个一个函数 )，招聘由行政部门负责，研发由技术部门负责等，这样就可以分工明确，结构清晰，方便管理，各部门之间还可以相互协调。

### 4) 函数的调用 ###

当调用函数时，需要关心5要素：

*  **头文件：** 包含指定的头文件
 *  **函数名字：** 函数名字必须和头文件声明的名字一样
 *  **功能：** 需要知道此函数能干嘛后才调用
 *  **参数：** 参数类型要匹配
 *  **返回值：** 根据需要接收返回值

## 函数的定义 ##

### 1) 函数定义格式 ###

函数定义的一般形式：

返回类型 函数名(形式参数列表)
    {
        
    	数据定义部分;
    	执行语句部分;
    }

![在这里插入图片描述][6fee5692e6424d6a84ae8b1e9ed2b7ed.png]

### 2) 函数名字、形参、函数体、返回值 ###

#### 2.1 函数名 ####

理论上是可以随意起名字，最好起的名字见名知意，应该让用户看到这个函数名字就知道这个函数的功能。注意，函数名的后面有个圆换号`()`，代表这个为函数，不是普通的变量名。

#### 2.2 形参列表 ####

在定义函数时指定的形参，在未出现函数调用时，它们并不占内存中的存储单元，因此称它们是形式参数或虚拟参数，简称形参，表示它们并不是实际存在的数据，所以，形参里的变量不能赋值。

void max(int a = 10, int b = 20) // error, 形参不能赋值
    {
        
    }

在定义函数时指定的形参，必须是，类型+变量的形式

//1: right, 类型+变量
    void max(int a, int b)
    {
        
    }
    
    //2: 不建议只有类型，没有变量
    void max(int, int) // 只有声明的时候才可以不写形参名；那么在函数定义的时候其实也可以不用写的，但最好是写形参名。如果不写就不知道形参是什么，除非你用堆栈的方法来求得
    {
        
    }
    
    //3: error, 只有变量，没有类型
    int a, int b;
    void max(a, b)  // 如果没有出错，说明编译器给默认为int类型
    {
        
    }

在定义函数时指定的形参，可有可无，根据函数的需要来设计，如果没有形参，圆括号内容为空，或写一个void关键字：

// 没形参， 圆括号内容为空
    void max()
    {
        
    }
    
    // 没形参， 圆括号内容为void关键字
    void max(void)
    {
        
    }

#### 2.3 函数体 ####

花括号`{ }`里的内容即为函数体的内容，这里为函数功能实现的过程，这和以前的写代码没太大区别，以前我们把代码写在`main()`函数里，现在只是把这些写到别的函数里。

#### 2.4 返回值 ####

函数的返回值是通过函数中的`return`语句获得的，`return`后面的值也可以是一个表达式。

1.  尽量保证`return`语句中表达式的值和函数返回类型是同一类型。

int max() // 函数的返回值为int类型
    {
        
    	int a = 10;
    	return a;// 返回值a为int类型，函数返回类型也是int，匹配
    }

1.  如果函数返回的类型和`return`语句中表达式的值不一致，则以函数返回类型为准，即函数返回类型决定返回值的类型。对数值型数据，可以自动进行类型转换。

double max() // 函数的返回值为double类型
    {
        
    	int a = 10;
    	return a;// 返回值a为int类型，它会转为double类型再返回
    }

**注意：** 如果函数返回的类型和`return`语句中表达式的值不一致，而它又无法自动进行类型转换，程序则会报错。

1.  `return`语句的另一个作用为中断`return`所在的执行函数，类似于`break`中断循环、`switch`语句一样。

int max()
    {
        
    	return 1;// 执行到，函数已经被中断，所以下面的return 2无法被执行到
    	return 2;// 没有执行
    }

1.  如果函数带返回值，`return`后面必须跟着一个值，如果函数没有返回值，函数名字的前面必须写一个`void`关键字，这时候，我们写代码时也可以通过`return`中断函数(也可以不用)，只是这时，`return`后面不带内容( 分号“`;`”除外)。

void max()// 最好要有void关键字
    {
        
    	return; // 中断函数，这个可有可无
    }

## 函数的调用 ##

定义函数后，我们需要调用此函数才能执行到这个函数里的代码段。这和`main()`函数不一样，`main()`为编译器设定好自动调用的主函数，无需人为调用，我们都是在`main()`函数里调用别的函数，一个 C 程序里有且只有一个main()函数。

### 1) 函数执行流程 ###

#include <stdio.h>
    
    void print_test()
    {
        
    	printf("CSDN:cdtaogang\n");
    }
    
    int main()
    {
        
    	print_test();	// print_test函数的调用
    
    	return 0;
    }

> 1、进入main()函数  
> 2、调用print\_test()函数：  
> a.它会在main()函数的前寻找有没有一个名字叫“print\_test”的函数定义；  
> b.如果找到，接着检查函数的参数，这里调用函数时没有传参，函数定义也没有形参，参数类型匹配；  
> c.开始执行print\_test()函数，这时候，main()函数里面的执行会阻塞( 停 )在print\_test()这一行代码，等待print\_test()函数的执行。  
> 3、print\_test()函数执行完( 这里打印一句话 )，main()才会继续往下执行，执行到return 0, 程序执行完毕。

补充：可以通过打断点的方式去查看函数调用过程

![在这里插入图片描述][e44ffe574bc84e6ea115023985ba8c9f.png]

### 2) 函数的形参和实参 ###

*  形参出现在函数定义中，在整个函数体内都可以使用，离开该函数则不能使用。
 *  实参出现在主调函数中，进入被调函数后，实参也不能使用。
 *  实参变量对形参变量的数据传递是“值传递”，即单向传递，只由实参传给形参，而不能由形参传回来给实参。
 *  在调用函数时，编译系统临时给形参分配存储单元。调用结束后，形参单元被释放。实参单元与形参单元是不同的单元。调用结束后，形参单元被释放，函数调用结束返回主调函数后则不能再使用该形参变量。实参单元仍保留并维持原值。因此，在执行一个被调用函数时，形参的值如果发生改变，并不会改变主调函数中实参的值。

### 3) 无参无返回值函数调用 ###

如果是调用无参函数，则不能加上“实参”，但括号不能省略。

#include <stdio.h>
    
    
    // 无参无返回值函数
    void func()
    {
        
    	printf("hello func函数\n");
    	return;
    }
    
    int main()
    {
        	
    	printf("hello main函数\n");
    	//函数的调用  函数名+()
    	func();// right, 圆括号()不能省略
    	// func(250); // error, 函数定义时没有参数
    	return 0;
    }

![在这里插入图片描述][b9622cac100f45c8b75a94c6e54a4796.png]

### 4) 有参无返回值函数调用 ###

a) 如果实参表列包含多个实参，则各参数间用逗号隔开。

![在这里插入图片描述][3339078e6c11455a91cca99e18bf7df4.png]

b) 实参与形参的个数应相等，类型应匹配(相同或赋值兼容)。实参与形参按顺序对应，一对一地传递数据。

#include<stdio.h>
    
    
    //定义一个有参无返回值函数
    //函数定义时()里面的参数叫形参,(因为这个形参只是形式上的参数,定义函数时没有给形参开辟空间)
    //形参只有在被调用时才会分配空间
    //形参的定义  类型名+变量名
    void sum(int a, int b) {
        
    
    	int c = a + b;
    	printf("a+b=%d\n", c);
    	return;
    }
    
    int main() {
        
    
    	//sum(); // 调用有参函数时，不能不传递实参
    	// 调用函数时，()里面的参数叫实参
    	sum(10, 20);
    	//sum(10);  // error 实参与形参个数不匹配
    	sum('a', 50); // 类型不匹配  字符'a'转为强转为int类型也就是ASCII码值97，所以结果为147
    	              // C语言调用函数时，实参和形参的个数与对应类型应该保持一致，但并不是必须保持一致。
    				  //举个简单的例子：定义的形参为int类型，在调用函数传入实参时传入一个float类型的值，则形参把该float自动转为int类型进行操作
    	return 0;
    }

![在这里插入图片描述][3dfde5d89282467395a5855aa89832f0.png]  
c) 实参可以是常量、变量或表达式，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。所以，这里的变量是在圆括号`( )`外面定义好、赋好值的变量。

![在这里插入图片描述][eca25444c9c1413f81d0175855d02044.png]

### 5) 有参有返回值函数调用 ###

a）如果函数定义没有返回值，函数调用时不能写`void`关键字，调用函数时也不能接收函数的返回值。

// 函数的定义
    void test()
    {
        
    }
    
    int main()
    {
        
    	// 函数的调用
    	test(); // right
    	void test(); // error, void关键字只能出现在定义，不可能出现在调用的地方
    	int a = test();	// error, 函数定义根本就没有返回值
    
    	return 0;
    }

b）如果函数定义有返回值，这个返回值我们根据用户需要可用可不用，但是，假如我们需要使用这个函数返回值，我们需要定义一个匹配类型的变量来接收

#include<stdio.h>
    
    
    //定义一个有参有返回值函数
    int sum2(int a, int b) {
        
    
    	
    	int c = a + b;
    
    	return c;
    	//return a + b; // 返回值可以为常量,可以为变量,可以为表达式,只要返回值的类型和定义函数的类型匹配即可
    
    
    }
    
    int main() {
        
    	// 调用有返回值函数时，可以接收返回值，也可以不接
    	// sum2(20, 30);
    	// 返回的类型和所接收返回值的变量类型匹配
    	// 参数的传递，只能是单向传递（实参传给形参）
    	int x = 12;
    	int y = 15;
    	int res = sum2(x, y);
    	printf("res=%d", res);
    
    	return 0;
    }

![在这里插入图片描述][9c0afab43d064719a895ba3e04796950.png]

![在这里插入图片描述][9d4f27ae26b24517a0b91d4f60b987b8.png]

c）函数调用，将实参传给形参，形参的值的改变不会改变到实参的值，也就是说如果实参传递的是变量本身，那么只会将变量值进行传递，而不会把变量本身的空间给传进去。

#include<stdio.h>
    
    
    //定义一个有参有返回值函数
    int sum2(int a, int b) {
        
    
    	
    	int c = a + b;
    
    	return c;
    	//return a + b; // 返回值可以为常量,可以为变量,可以为表达式,只要返回值的类型和定义函数的类型匹配即可
    
    
    }
    
    void swap(int c, int d) {
        
    
    	int e = c;
    	c = d;
    	d = e;
    	printf("c=%d, d=%d\n", c, d);
    
    
    }
    
    int main() {
        
    	// 调用有返回值函数时，可以接收返回值，也可以不接
    	//sum2(20, 30);
    	// 返回的类型和所接收返回值的变量类型匹配
    	// 参数的传递，只能是单向传递（实参传给形参）
    	int x = 12;
    	int y = 15;
    	int res = sum2(x, y);
    	printf("res=%d\n", res);
    	// 如果实参传递的是变量本身，那么只会将变量值进行传递，而不会把变量本身的空间给传进去
    	swap(x, y);
    	printf("x=%d, y=%d", x, y);
    	
    	return 0;
    }

![在这里插入图片描述][0235e5ab54d9431ebd9752c4c65cf605.png]

## 函数的声明 ##

如果使用用户自己定义的函数，而该函数与调用它的函数（即主调函数）不在同一文件中，或者函数定义的位置在主调函数之后，则必须在调用此函数之前对被调用的函数作声明。

所谓函数声明，就是在函数尚在未定义的情况下，事先将该函数的有关信息通知编译系统，相当于告诉编译器，函数在后面定义，以便使编译能正常进行。

**注意：**一个函数只能被定义一次，但可以声明多次。

在`c`语言中，如果定义函数时选择默认返回类型（即`int`类型），则这个函数放在任意位置都是可以被别的程序调用的，而且编译无误~ 但是这是一个很大的陷阱。你会发现当你给那个函数任意个参数时，编译也能通过，还能执行，但是很可能产生错误。这里是个隐式声明的问题`C`语言的编译器 在没有发现函数原型的时候会自动产生一个隐式的函数声明，这个隐式的函数声明 的返回值是`int`。如下博主将定义函数放在`main`函数的后面，没有去声明定义函数，但也能正常运行（也有可能是现在的编译器比较智能）。

#include <stdio.h>
    
    
    int main()
    {
        
    	int a = 10, b = 25, num_max = 0;
    	num_max = max(a, b); // 函数的调用
    
    	printf("num_max = %d\n", num_max);
    
    	return 0;
    }
    
    // 函数的定义
    int max(int x, int y)
    {
        
    	return x > y ? x : y;
    }

![在这里插入图片描述][78d80fa8b0c2481786049d5bd2abf8e9.png]

如果将如上定义函数修改为无返回值函数，则无法运行成功

#include <stdio.h>
    
    
    int main()
    {
        
    	int a = 10, b = 25, num_max = 0;
    	max(a, b); // 函数的调用
    
    	printf("num_max = %d\n", num_max);
    
    	return 0;
    }
    
    // 函数的定义
    void max(int x, int y)
    {
        
    	return;
    }

![在这里插入图片描述][484201248538461aa6ce7efcd85381da.png]

对`max`定义函数进行声明即可使编译能正常进行

#include <stdio.h>
    //声明的作用就是告诉编译器这个东西在其他地方定义
    
    
    //函数的声明不加extern 也是可以的
    //extern void max(int x, int y);
    
    //函数的声明,把函数的定义形式放在调用之前
    //没有函数体就是函数的声明,有函数体就是函数的定义
    //函数声明不用写函数体
    //声明函数时需要加分号
    void max(int x, int y); // 函数的声明，分号不能省略
     //void max(int, int); // 另一种方式
    
    int main()
    {
        
    	int a = 10, b = 25, num_max = 0;
    	// void max(int x, int y);  //只要放在调用之前声明就可以
    	max(a, b); // 函数的调用
    	printf("num_max = %d\n", num_max);
    
    	return 0;
    }
    
    // 函数的定义
    void max(int x, int y)
    {
        
    	return;
    }

![在这里插入图片描述][a250e96561f246c7bc89cfa68020181d.png]

**函数定义和声明的区别：**  
1）定义是指对函数功能的确立，包括指定函数名、函数类型、形参及其类型、函数体等，它是一个完整的、独立的函数单位。  
2）声明的作用则是把函数的名字、函数类型以及形参的个数、类型和顺序(注意，不包括函数体)通知编译系统，以便在对包含函数调用的语句进行编译时，据此对其进行对照检查（例如函数名是否正确，实参与形参的类型和个数是否一致）。

## return函数与exit函数 ##

如果`return`在子函数中调用只会结束子函数，如果`return`在`main`函数中,会结束整个程序；而`exit` 是一个库函数,用来结束整个程序，不管`exit`在哪里调用,都会结束整个程序。

所以在`main`函数中调用`exit`和`return`结果是一样的，但在子函数中调用`return`只是代表子函数终止了，在子函数中调用`exit`，那么程序终止。

#include <stdio.h>
    #include <stdlib.h>
    
    void fun()
    {
        
    	printf("fun\n");
    	//return;
    	exit(0);
    }
    
    int main()
    {
        	
    	// exit(0);
    	fun();
    	while (1); // 死循环
    
    	return 0;
    }

![在这里插入图片描述][cbc2b861eb844ed9ad1abc0c7d9529ef.png]

## 多文件(分文件)编程 ##

### 1) 分文件编程 ###

*  把函数声明放在头文件`xxx.h`中，在主函数中包含相应头文件
 *  在头文件对应的`xxx.c`中实现`xxx.h`声明的函数

创建`main.c`和`fun.c`两个文件，`main.c`文件中只有`main`函数负责调用`fun.c`文件中的各个函数，如定义了计算最大、最小值，求和、求差几个函数  
  
**main.c文件**

#include <stdio.h>
    
    int main() {
        
    
    	int a = 10;
    	int b = 20;
    	
    	printf("max=%d\n", my_max(a, b));
    	printf("min=%d\n", my_min(a, b));
    	printf("sum=%d\n", my_sum(a, b));
    	printf("sub=%d\n", my_sub(a, b));
    
    	return 0;
    }

**fun.c文件**

int my_max(int a, int b) {
        
    
    	return a > b ? a : b;
    }
    
    int my_min(int a, int b) {
        
    
    	return a < b ? a : b;
    }
    
    int my_sum(int a, int b) {
        
    
    	return a + b;
    }
    
    int my_sub(int a, int b) {
        
    
    	return a - b;
    }

![在这里插入图片描述][d1b7e9cd1ec74f369ecfdf29eef7614a.png]

在`main`函数中并没有声明`fun.c`中定义的函数，但此时运行程序，会发现没有出错，目前的编译器是可以编译过去的，但是会有警告信息  
  
![在这里插入图片描述][8267f994a5544eefb235697d75394258.png]

那么在调用`fun.c`文件中的函数之前去进行声明，警告消失  
  
![在这里插入图片描述][9d9262c8881b44f3af21cef0fbc96608.png]

如果`fun.c`文件中的函数非常多，成百上千的，每次使用都要去声明，太麻烦了，那么我们可以通过定义头文件，在头文件中进行声明，最后在`main.c`文件中引入头文件就行了。  
  
![在这里插入图片描述][6769b80897854e06ab031168e1fb6bc6.png]

### 2) 防止头文件重复包含 ###

当一个项目比较大时，往往都是分文件，这时候有可能不小心把同一个头文件 include 多次，或者头文件嵌套包含。  
  
`a.h` 中包含 `b.h` ：

#include "b.h"

`b.h` 中包含 `a.h` ：

#include "a.h"

`main.c` 中使用其中头文件：

#include "a.h"
    
    int main()
    {
        
    	return 0;
    }

编译上面的例子，会出现如下错误：

![在这里插入图片描述][d4d9c478e916416ebc9c38726c760789.png]

还有一种情况就是，当在`main.c`中`include`同一个头文件多次，并且这个头文件中定义了变量，那么就会导致出现同一变量被初始化多次的情况；那么为了避免这种情况的发送，我们在`.h`头文件中只进行声明，而不进行定义，定义都在`.c`文件中即可。

![在这里插入图片描述][8236cde6ccc94b27ab5cc1355dad27e9.png]

为了避免同一个文件被`include`多次，`C/C++`中有两种方式，一种是 `#ifndef` 方式，一种是 `#pragma once` 方式。

**方法一：** 通过`#ifndef`（if not defined）来对宏是否定义存在进行判断，不存在则进行定义宏，存在不进行定义

#ifndef __SOMEFILE_H__   // 
    #define __SOMEFILE_H__
    
    // 声明语句
    
    #endif

**fun.h文件**

// 头文件中只进行声明，不定义
    // 定义只在.c文件中定义
    
    // 方法一：
    // 为了避免宏的名字重复，我们一般将宏的名字与文件名保持相同，大写表示)
    #ifndef __FUN_H__  // 如果没有定义 __FUN_H__ 这个宏，成立
    #define __FUN_H__  // 定义 __FUN_H__ 宏
    int my_max(int a, int b);
    int my_min(int a, int b);
    int my_sum(int a, int b);
    int my_sub(int a, int b);
    int a = 10;
    #endif

![在这里插入图片描述][3633b104b94846d7a9c0cddaed066620.png]

**方法二：** 直接使用预处理指令`#pragma once`，它是一个比较常用的C/C++预处理指令，只要在头文件的最开始加入这条预处理指令，就能够保证头文件只被编译一次。

#pragma once
    
    // 声明语句

![在这里插入图片描述][6fe07591f7f542f3adb55440cde39466.png]

[6fee5692e6424d6a84ae8b1e9ed2b7ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e280759ca0a84c0da312104c6ca3fe6f.png
[e44ffe574bc84e6ea115023985ba8c9f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d15d5a453b1f4a8d91fd527bc7e54696.png
[b9622cac100f45c8b75a94c6e54a4796.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/71b15585b13d4f0385030b49e0056f9d.png
[3339078e6c11455a91cca99e18bf7df4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/a294531b50c24487ade24a0f1524bf2f.png
[3dfde5d89282467395a5855aa89832f0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/ab7556b39c3248518cef9a9f0f7280f7.png
[eca25444c9c1413f81d0175855d02044.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d61f9ed47f364961bf846815ef608204.png
[9c0afab43d064719a895ba3e04796950.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/1a446bf85a5d454092891dea650eb5ae.png
[9d4f27ae26b24517a0b91d4f60b987b8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/db5dd3acd20b4a779253d9044b32302a.png
[0235e5ab54d9431ebd9752c4c65cf605.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c3b7d1cc056f49f89a96f3877a43f0af.png
[78d80fa8b0c2481786049d5bd2abf8e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/0953e65be8a24aab8e0c7955bb7f962e.png
[484201248538461aa6ce7efcd85381da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/98be2e542b89422687194540a6109b5e.png
[a250e96561f246c7bc89cfa68020181d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f7ddedd3acbd4f84a0821fa38a3353ae.png
[cbc2b861eb844ed9ad1abc0c7d9529ef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/9371bc06ae6d4f09b28c0b241b8b6213.png
[d1b7e9cd1ec74f369ecfdf29eef7614a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/7b4d5a78bc50401799823564412c26cd.png
[8267f994a5544eefb235697d75394258.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c0a4780289c243caa882f5f40fd3e6d6.png
[9d9262c8881b44f3af21cef0fbc96608.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f853d9c408334144abab6e7ac1b07a69.png
[6769b80897854e06ab031168e1fb6bc6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c93ffb6620ba4aaf97eff33bbab117ff.png
[d4d9c478e916416ebc9c38726c760789.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/fb2c8519b3884a6db937d4e91f7edf16.png
[8236cde6ccc94b27ab5cc1355dad27e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/91adb6c4acda4b159f3960b8c11c8f1e.png
[3633b104b94846d7a9c0cddaed066620.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/56ba4d04651b4e81b1da853c05c9a6c0.png
[6fe07591f7f542f3adb55440cde39466.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/01143a53789b4a4fa25a3cbafa2def6c.png