【C++深入浅出】初识C++中篇（引用、内联函数）

女爷i 2024-04-25 20:05 80阅读 0赞

![8c630f308ebf4effa17560dae8da4b70.jpeg][]

--------------------

**目录**

一. 前言

二. 引用

2.1 引用的概念

2.2 引用的使用

2.3 引用的特性

2.4 常引用

2.5 引用的使用场景

2.6 传值、传引用效率比较

2.7 引用和指针的区别

三. 内联函数

3.1 内联函数的概念

3.2 内联函数的特性

--------------------

### 一. 前言 ###

上期说道，C++是在C的基础之上，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式等。我们介绍了部分C++为了补充C语言语法上的不足而新增的内容，如命名空间，缺省参数，函数重载等等，上期传送门![f41d6b2f862c46ee9761486e28f64af8.jpeg][][【C++深入浅出】初识C++（上篇）![icon-default.png_t_N6B9][]http://t.csdn.cn/UjbIo][C_C_icon-default.png_t_N6B9_http_t.csdn.cn_UjbIo] 本期将继续介绍C++剩下的一些有趣的功能，如引用，内联函数等等，这也是为了后面的类和对象打好基础。![b39857ee93eb4c28b24ce9c787bbe3e9.gif][]

**话不多说，直接上菜！！！**

### 二. 引用 ###

#### 2.1 引用的概念 ####

引用并不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

引用就相当于我们给别人起昵称。例如你叫你女朋友小笨猪，那么对你而言，小笨猪就是你的女朋友，和叫名字是一个意思，既不是其他任何人，你也不会因此多一个女朋友![1e9c319d790f41e18cc66d51e3ff9593.gif][]

#### 2.2 引用的使用 ####

**类型& 引用变量名(对象名) = 引用实体**

void Test()
    {
    	int a = 10;
    	int& ra = a; //<====定义引用类型，此时ra就是变量a的别名，ra与a是同一块内存空间
    	printf("a的地址为%p\n", &a);
    	printf("ra的地址为%p\n", &ra);
    }
    
    int main()
    {
    	Test();
    	return 0;
    }

![72e33e89fc3548c6980e0ffeca7c6c16.png][]

> 我们看到变量a和引用变量ra的地址是一样的，说明它们共用同一块内存空间。![f63855ee4a754354a7cd04ab12a0f29f.png][]

#### 2.3 引用的特性 ####

使用引用时需要注意以下几点特性![75293561f3eb4fd492fb0a785ee999a7.png][]

**1、引用在定义时必须初始化**

int main()
    {
    	int a = 10;
    	int& b; //错误写法，会报错
    	int& b=a; //正确写法
    	return 0;
    }

**2、一个变量可以有多个引用**

int main()
    {
    	int a = 10;
    	//下面的b，c，d均是变量a的别名
    	int& b = a;
    	int& c = a;
    	int& d = c;
    	printf("%p %p %p %p\n", &a,&b,&c,&d);
    	return 0;
    }

![e960a45836954fd5aa464029fd0ad947.png][]

**3、引用一旦引用一个实体，就不能引用其他实体**

int main()
    {
    	int a = 10;
    	int& b = a; //b是a的别名
    	int c = 20; 
    
    	//能不能将b改成c的别名呢？
    	b = c; //不行，这条语句是将c的值赋给引用变量b，即修改变量a的值，并不是让b引用c
    
    	printf("&a = %p &b = %p &c = %p\n", &a,&b,&c);
    	printf("a = %d b = %d c = %d\n", a, b, c);
    	return 0;
    }

![d9e474bfa3a741f292b66dc796383665.png][]

**4、引用类型必须和引用实体是同种类型的**

int main()
    {
    	int a = 10;
    	double& b = a; //这种写法会报错
    	return 0;
    }

![b8164e91a2dd47ba8198eea16828a225.png][]

我们看到编译器报错说非常量限定，那如果我们加上const修饰呢？如下：

const double& b = a;

![d10cb848bb8a4136949a6fd7cabeea9c.png][]

我们惊讶地发现通过了编译，说明上面不是因为int和double类型不一样而报错，那究竟是为什么呢？下面我们来分析分析![201df5c9e29848589466e8e75ead7441.gif][]

实际上，由于引用实体和引用变量的类型不同，编译器会自动进行隐式类型转换。编译器会生成一个double类型的临时变量tmp，然后将a的内容以某种形式放到临时变量tmp中，最后再让b引用临时变量tmp。

int main()
    {
    	int a = 10;
    	const double& b = a;
    
    	//类似于下面的步骤
    	int a = 10;
    	double tmp = a; //将a的值转换赋给tmp
    	const double& b = tmp; //b再引用tmp
    	return 0;
    }

![92871b0df1854c3cbcea89a807c450ef.png][]

由于临时变量具有常属性，因此tmp的类型就是const double，用double类型的引用变量引用const double类型的变量，这无疑是一种权限的放大，是不被允许的。就好比别人大门紧缩不然你进，你偏偏另辟蹊径从窗户翻入，这无疑是犯法的，私闯民宅![6efebacd8b884fadb39882a351a6a906.gif][]。这就是为什么编译器会报出非常量限定的错误的原因，引用变量d需要加上const修饰，权限的平移是被允许的。

最后，本来临时变量tmp在当前语句结束后就会被销毁，但此时被b所引用，其生命周期就自动被延长了。

分析了这么多，下面我们用代码来进行验证一下：

int main()
    {
    	int a = 10;
    	const double& b = a;
    
    	printf("&a = %p , &b = %p\n", &a, &b); //求a，b空间的地址
    
    	printf("修改前 a = %d , b = %.2lf\n", a, b);
    	a = 20;
        //b = 30; //这句代码会报错，被const修饰的变量不可修改
    	printf("修改后 a = %d , b = %.2lf\n", a, b);
    	return 0;
    }

![b201d73eff414028a42727bd4da1d600.png][]

> 我们发现a的地址和b的地址不同，这说明了b并不是变量a的引用，而是引用了新形成的临时变量。并且，当我们对a进行修改时，b中的内容并没有发生改变，这也印证了a和b不是同一块内存空间。最后，当我们想要对b的内容进行修改时，编译器会直接报错，说明b所在的空间具有常属性。

--------------------

#### 2.4 常引用 ####

被const关键字修饰的引用变量我们称为常引用。我们无法通过常引用来修改引用实体的值，如下：

#include<iostream>
    using namespace std;
    int main()
    {
    	int a = 10;
    	const int& b = a;
    	//b++; //会报错,b是常引用，无法修改
    	a++; //a是普通变量，允许修改
    	cout << "a = " << a <<' ' << "b = " << b;
    	return 0;
    }

![3dbd7988a339471695d169907bd6bf96.png][]

前面我们提到了权限不能放大，也就是说：普通引用不能引用常属性变量。但是，权限允许平移或者缩小，即常引用可以引用常属性变量、常引用可以引用普通变量。如下：

#include<iostream>
    using namespace std;
    int main()
    {
    	int a = 10;
    	const int& b = a; //权限的缩小，const引用引用普通变量，编译正常
    
    	const int aa = 10;
    	const int& bb = aa;//权限的缩小，const引用引用const变量，编译正常
    	int& cc = aa;//权限的放大，普通引用引用const变量，报错
    
    	return 0;
    }

--------------------

#### 2.5 引用的使用场景 ####

引用的使用场景一般有两个：做函数参数、做函数返回值。

**1、引用作为函数参数**

在C语言中，如果我们调用函数时使用传值调用，那么形参的改变是不会影响实参的，形参是实参的临时拷贝。如果我们想在函数中对实参进行修改，那就必须使用传址调用，通过地址对实参的值进行修改。

而在C++中，新增了引用的语法，我们可以使用引用作为函数的形参，此时形参就是实参的一个别名，并不会额外开辟空间，形参和实参共同内存空间，修改形参也就是对实参进行修改。具体实现方式如下![04c43166ab6a412c9c4bab787a06a5a5.png][]

#include<iostream>
    using namespace std;
    void ModifyFun(int& x) //引用作为函数参数
    {
    	x = 100;
    }
    int main()
    {
    	int a = 10;
    	cout << "调用前" << a << endl;
    	ModifyFun(a);
    	cout << "调用后" << a << endl;
    }

![d98989ef2efd4aed833396fcebbfaee8.png][]

--------------------

#include<iostream>
    using namespace std;
    void Swap(int& x , int& y) //引用作为函数参数
    {
    	int tmp = x;
    	x = y;
    	y = tmp;
    }
    int main()
    {
    	int a = 10;
    	int b = 20;
    	cout << "交换前:" << "a = " << a << " b = " << b << endl;
    	Swap(a, b);
    	cout << "交换后:" << "a = " << a << " b = " << b << endl;
    }

![abd58a688c65477297d1ad42628bda6b.png][]

**2、引用作为函数返回值**

引用也可以作为函数的返回值，如下：

#include<iostream>
    using namespace std;
    int& Count()
    {
    	static int n = 0; //n是一个静态变量，函数调用结束后不会销毁
    	cout << n << endl;;
    	return n;
    }
    int main()
    {
    	int& k = Count();
    	k++;
    	Count();
    	return 0;
    }

![86e3356309bc4279852b2be924d3ddd5.png][]

> 在Count()函数通过引用返回n，此时main函数中的引用变量k就是n的别名，当我们在main函数中修改k，就相当于对静态变量n做修改。

但是，如果以下情况使用引用返回会出现什么情况呢？

int& Add(int a, int b)
    {
    	int c = a + b; //c是局部变量，Add调用结束后被销毁
    	return c;
    }
    int main()
    {
    	int& ret = Add(1, 2);
    	Add(3, 4);
    	cout << "Add(1, 2) is :" << ret << endl;
    	return 0;
    }

![fed295b9b37346e4a5f3efc1b842f97e.png][]

> 很惊讶的发现，最终ret变量的值不是3而是7，为什么呢？![fc2e58a792e3441185309686ee08df0e.gif][]
> 
> 这就要来谈谈上述代码出现的野引用问题了。

我们通过下图来进行分析![4d9134b9cac046f38129bc94d7db072d.png][]

![c8a79b0068224a1f9fe2f19b9fdac945.png][]

>  **总结：**函数返回时，如果出了函数作用域，返回对象还在(还没销毁还给系统)，则可以使用  
> 引用返回；如果已经还给系统了，则必须使用传值返回。

#### 2.6 传值、传引用效率比较 ####

在C/C++中，以值作为参数或者返回值类型，在传参和返回期间，函数并不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时拷贝，因此用值作为参数或者返回值类型，需要额外进行拷贝，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

而如果以引用作为参数或者返回值类型，由于引用是作为变量的别名，并不会额外开辟空间形成拷贝。因此在传参和返回期间，就相当于直接传递实参或将变量本身直接返回，效率大大提升。下面我们通过代码来更直观地看看二者的效率差距：

**值和引用作为函数参数的效率差距**

#include <time.h>
    struct A { int a[10000]; };
    void TestFunc1(A a)
    {
    	;
    }
    void TestFunc2(A& a)
    {
    	;
    }
    void TestRefAndValue()
    {
    	A a;
    	// 以值作为函数参数
    	size_t begin1 = clock(); //clock()函数返回程序运行到调用clock()函数所耗费的时间，单位是ms
    	for (size_t i = 0; i < 100000; ++i)
    		TestFunc1(a);
    	size_t end1 = clock();
    
    	// 以引用作为函数参数
    	size_t begin2 = clock();
    	for (size_t i = 0; i < 100000; ++i)
    		TestFunc2(a);
    	size_t end2 = clock();
    
    	// 分别计算两个函数运行结束后的时间
    	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
    	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
    }
    int main()
    {
    	TestRefAndValue();
    	return 0;
    }

![cfd14c6208234a30b9ff433aec46f826.png][]

--------------------

**值和引用作为返回值类型的效率差距**

#include <time.h>
    struct A 
    {
    	int a[10000]; 
    }a;
    // 值返回
    A TestFunc1() 
    { 
    	return a; 
    }
    // 引用返回
    A& TestFunc2() 
    { 
    	return a; 
    }
    void TestRefAndValue()
    {
    	// 以值作为函数的返回值类型
    	size_t begin1 = clock();
    	for (size_t i = 0; i < 100000; ++i)
    		TestFunc1();
    	size_t end1 = clock();
    
    	// 以引用作为函数的返回值类型
    	size_t begin2 = clock();
    	for (size_t i = 0; i < 100000; ++i)
    		TestFunc2();
    	size_t end2 = clock();
    
    	// 计算两个函数运算完成之后的时间
    	cout << "TestFunc1 time:" << end1 - begin1 << endl;
    	cout << "TestFunc2 time:" << end2 - begin2 << endl;
    }
    int main()
    {
    	TestRefAndValue();
    	return 0;
    }

![9c830e09ac7f4b7c8d7ecc0ad0624768.png][]

> 通过上述代码的比较，我们发现传值和引用在作为传参以及返回值类型上效率相差很大。传引用的效率远高于传值。因此能使用引用就尽量使用引用，提高效率。

#### 2.7 引用和指针的区别 ####

在**语法概念**上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

但在**底层实现**上实际是有空间的，因为引用是按照指针方式来实现的。这点我们可以参照二者编译后生成的汇编代码证明![612cc7b583f247d29293b7cef5773148.gif][]

int main()
    {
    	//引用
    	int a = 10;
    	int& ra = a;
    	//指针
    	ra = 20;
    	int* pa = &a;
    	*pa = 20;
    	return 0;
    }

![da52b2eeba13405d9081ec6326d7b866.png][]

> 可见，引用和指针的汇编代码是一模一样的，最后都是通过变量a的地址来修改a。
> 
> --------------------
> 
> 不过，引用和指针还是有**不同点**的，如下：
> 
> 1.  引用概念上定义一个变量的别名，指针存储一个变量地址。
> 2.  引用在定义时必须初始化，指针没有要求
> 3.  引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
> 4.  引用必须初始化，故没有NULL引用，但有NULL指针
> 5.  sizeof的含义不同，sizeof（引用变量）的结果为引用实体的类型大小，而sizeof（指针）始终是地址空间所占字节个数(32位平台下占4个字节，64位平台下占8个字节)
> 6.  引用自增即引用的实体增加1，指针自增即指针向后偏移一个类型的大小
> 7.  有多级指针，但是没有多级引用
> 8.  访问实体方式不同，指针需要显式解引用，引用编译器自己处理
> 9.  从安全性的角度，引用比指针使用起来相对更安全

--------------------

### 三. 内联函数 ###

#### 3.1 内联函数的概念 ####

以inline关键字修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，不会调用函数建立栈帧，因此内联函数提升程序运行的效率。  
我们可以通过汇编代码来验证加上inline的函数是否会被调用![63f3ed229e5247a39d5f880ed6f93745.png][]

**没加inline关键字:**

int Add(int x, int y)
    {
    	return x + y;
    }
    int main()
    {
    	int ans = 0;
    	ans = Add(1, 2);
    	return 0;
    }

![c907cfea56c545b6a0641cde268b368c.png][]

**加上inline关键字:**

inline int Add(int x, int y)
    {
    	return x + y;
    }
    int main()
    {
    	int ans = 0;
    	ans = Add(1, 2);
    	return 0;
    }

![e7ca31024efa4db8a9abaf0aa30a4eae.png][]

> 可以看到，内联函数并不会生成对应的call指令，而是直接被替换到函数调用处，减少了调用函数建立栈帧的开销。

**注意事项：**

内联函数的效果需要在release模式才会体现。因为在debug模式下编译器默认不会对代码进行优化，顾不会进行展开。当然我们也可以进行设置，方法如下（VS2022）：

**1、找到当前项目属性设置页：**

![e63e0bfa27fb410d84bacbf2b67ac676.png][]

**2、设置调试信息格式：**

![7cb5abb17de6465fb88db38f0563cd23.png][]

**3、设置内联函数扩展：**

![17fefa0afbf34b63a05a5ae3f1c71d9b.png][]

--------------------

#### 3.2 内联函数的特性 ####

> 主要有如下几点特性：
> 
> 1.  inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用。缺陷：可能会使目标文件变大；优势：少了调用建立栈帧开销，提高程序运行效率。
> 2.  inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建  
>     议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性(编译器也是很聪明的，可不要贪杯噢![52c16760c6cb49238047b1dcb4b12b03.gif][])。以下为**《C++prime》第五版**关于inline的描述：![bb635758a65a4947a212a3e3ce2aeab1.png][]
> 3.  inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，符号表中就没有函数地址了，链接就会找不到。
>     
>         // in.h
>         #include <iostream>
>         using namespace std;
>         inline void f(int i);
>         
>         // in.cpp
>         #include "in.h"
>         void fun(int i)
>         {
>             cout << i << endl;
>         }
>         
>         // main.cpp
>         #include "in.h"
>         int main()
>         {
>             fun(10);
>             return 0;
>         }
>     
>     ![7864c4b890654e23ad5db891ce0331fb.png][]
>     
>     **报错原因：**由于in.h文件中只有函数的声明没有定义，顾在编译阶段main.cpp中的fun() 函数无法进行展开，只能在链接阶段进行链接。但是由于in.cpp的fun()函数被声明为内联函数，fun()函数并不会进入符号表，最后就会导致链接时找不到函数地址，报错。

--------------------

***以上，就是本期的全部内容啦*****?**

***制作不易，能否点个赞再走呢*****?**

[8c630f308ebf4effa17560dae8da4b70.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/7c66a53517c84ad2a961ddb1892e2423.jpeg
[f41d6b2f862c46ee9761486e28f64af8.jpeg]: https://img-blog.csdnimg.cn/f41d6b2f862c46ee9761486e28f64af8.jpeg
[icon-default.png_t_N6B9]: https://csdnimg.cn/release/blog_editor_html/release2.3.5/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=N6B9
[C_C_icon-default.png_t_N6B9_http_t.csdn.cn_UjbIo]: http://t.csdn.cn/UjbIo
[b39857ee93eb4c28b24ce9c787bbe3e9.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/9a1b6d0301b345cb8d71a3bfd314f5f4.gif
[1e9c319d790f41e18cc66d51e3ff9593.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/a4f23cee0fc441aebc6e4c8a30e0df35.gif
[72e33e89fc3548c6980e0ffeca7c6c16.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/fd7aefb693b34967bc235e875efcd9f8.png
[f63855ee4a754354a7cd04ab12a0f29f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/4fb4644baf29499881f7c5018ef35cc6.png
[75293561f3eb4fd492fb0a785ee999a7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/9c1a2340eadb4a0289b2008db1a2c1de.png
[e960a45836954fd5aa464029fd0ad947.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/6f8784c36e224cb786595cdb2c032657.png
[d9e474bfa3a741f292b66dc796383665.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/29f38495f0f44880bb566bd06c5bc990.png
[b8164e91a2dd47ba8198eea16828a225.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/eee21412a45547ca8867e18553ae19e4.png
[d10cb848bb8a4136949a6fd7cabeea9c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/7dbea72cc403451dbfd03417ba4d9351.png
[201df5c9e29848589466e8e75ead7441.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/7988b6572d78422d83f823506af5af91.gif
[92871b0df1854c3cbcea89a807c450ef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/67df3f08361447c8aebb9fe1bbc72385.png
[6efebacd8b884fadb39882a351a6a906.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/664a7deb60cf4b8b9d8a05019d592162.gif
[b201d73eff414028a42727bd4da1d600.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/9f2af6e12f8145c4b8fc1fd2402ddc87.png
[3dbd7988a339471695d169907bd6bf96.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/ae52e1159eda45a0b4fcad5864ac85a2.png
[04c43166ab6a412c9c4bab787a06a5a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/8c7410039fd94e7ca82625c7234cab0a.png
[d98989ef2efd4aed833396fcebbfaee8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/81239dd9ab904e518737546d9246e8f1.png
[abd58a688c65477297d1ad42628bda6b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/c4dd8ae71d2e4a89b0768c1b9da40a3a.png
[86e3356309bc4279852b2be924d3ddd5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/fac904c06fc144c98187dc6195975c57.png
[fed295b9b37346e4a5f3efc1b842f97e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/0c5e32812df1494d93d083a76053f64a.png
[fc2e58a792e3441185309686ee08df0e.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/86f34f2bd3474afcb10ceb8b48e129ef.gif
[4d9134b9cac046f38129bc94d7db072d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/7cbb6cf41e784d3c854c700a3f79dffd.png
[c8a79b0068224a1f9fe2f19b9fdac945.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/2837f87a522f40cb9e732fab028b9899.png
[cfd14c6208234a30b9ff433aec46f826.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/8bbef965cfa9401d9fcfa74ec47fa2bb.png
[9c830e09ac7f4b7c8d7ecc0ad0624768.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/94820e2d02c443fd845d217c33e0f0db.png
[612cc7b583f247d29293b7cef5773148.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/82226717ea09419c8daf1a88bbb95ee4.gif
[da52b2eeba13405d9081ec6326d7b866.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/6f260ad91c4e4c1eb03577386b2f13b5.png
[63f3ed229e5247a39d5f880ed6f93745.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/5120d58f88eb46bc856865abd686e31f.png
[c907cfea56c545b6a0641cde268b368c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/895524df4a044c22a75c665b590266b4.png
[e7ca31024efa4db8a9abaf0aa30a4eae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/24e5ff6a4ea64d73930684d356b4207f.png
[e63e0bfa27fb410d84bacbf2b67ac676.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/ebaeb7e657cd4e69abacbeaa31bcb189.png
[7cb5abb17de6465fb88db38f0563cd23.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/049ec900dd7846d6b43014372e11cc77.png
[17fefa0afbf34b63a05a5ae3f1c71d9b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/0c6206c122eb4b32b69f7bc1ac2ee56c.png
[52c16760c6cb49238047b1dcb4b12b03.gif]: https://img-blog.csdnimg.cn/52c16760c6cb49238047b1dcb4b12b03.gif
[bb635758a65a4947a212a3e3ce2aeab1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/0ffe509af9424b91a24282d2aa7a6876.png
[7864c4b890654e23ad5db891ce0331fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/8d4eed1282db45c88f0fbb133d87d305.png