带你快速了解字符(串)函数

淩亂°似流年 2024-04-23 20:25 78阅读 0赞

> ⭐ 作者：小胡\_不糊涂
> 
> ? 作者主页：[小胡\_不糊涂的个人主页][Link 1]
> 
> ? 持续更文，谢谢大家支持 ?

#### 文章目录 ####

*  本文重点
 *  1. strlen函数
 *   *  1.1 模拟实现
 *  2. strcpy函数
 *   *  2.1 模拟实现
 *  3. strcat函数
 *   *  3.1 模拟实现
 *  4. strcmp函数
 *   *  4.1 模拟实现
 *  5. strncpy函数
 *   *  5.1 模拟实现
 *  6. strncat函数
 *   *  6.1 模拟实现
 *  7. strncmp函数
 *   *  7.1 模拟实现
 *  8. strstr函数
 *   *  8.1 模拟实现
 *  9. strtok函数
 *  10. strerror函数
 *  11.memcpy函数
 *  12. memmove函数
 *  结束语

## 本文重点 ##

<table> 
 <thead> 
  <tr> 
   <th>函数作用</th> 
   <th>函数名</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>求字符串长度</td> 
   <td>strlen</td> 
  </tr> 
  <tr> 
   <td>长度不受限制的字符串函数</td> 
   <td>strcpy strcat strcmp</td> 
  </tr> 
  <tr> 
   <td>长度受限制的字符串函数</td> 
   <td>strncpy strncat strncmp</td> 
  </tr> 
  <tr> 
   <td>字符串查找</td> 
   <td>strstr strtok</td> 
  </tr> 
  <tr> 
   <td>错误信息报告</td> 
   <td>strerror</td> 
  </tr> 
  <tr> 
   <td>内存操作函数</td> 
   <td>memcpy memmove memset memcmp</td> 
  </tr> 
  <tr> 
   <td>字符操作</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

> C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在**常量字符串**中或者**字符数组**中。  
> 　  
> **字符串常量**适用于那些对它不做修改的字符串函数。

## 1. strlen函数 ##

**功能：** 获取字符串长度

size_t strlen ( const char * str );//返回字符串str的长度
    
    //str--字符串

字符串的长度由`终止空字符 '\0'`确定：字符串的长度与字符串开头和终止空字符之间的字符数一样长（不包括终止空字符本身）。

? **例如：**

char str[100]="string ";

定义了一个大小为 100 个字符的字符数组，但初始化 str 时使用的字符串的长度仅为 7 个字符。因此，当 sizeof(str) 的计算结果为 100 时，strlen(str) 返回 7。

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

> 通过 strlen函数 比较两个字符串大小

//有符号
    #include<stdio.h>
    #include<string.h>
    int main()
    {
        
    	const char* str1 = "abcdef";
    	const char* str2 = "bbb";
    	if ((int)strlen(str2) -(int) strlen(str1) > 0)
    	{
        
    		printf("str2>str1\n");
    	}
    	else
    	{
        
    		printf("srt1>str2\n");
    	}
    	return 0;
    }

? 打印结果：  
![在这里插入图片描述][53a831ff9d874b0e807f84595e252b4c.png]

//无符号的
    #include<stdio.h>
    #include<string.h>
    int main()
    {
        
    	const char* str1 = "abcdef";
    	const char* str2 = "bbb";
    	if (strlen(str2) - strlen(str1) > 0)
    	{
        
    		printf("str2>str1\n");
    	}
    	else
    	{
        
    		printf("srt1>str2\n");
    	}
    	return 0;
    }

? 打印结果：  
![在这里插入图片描述][d5238272233e4cbcaa6d46f58a48d92f.png]  
`因为函数返回值是无符号的`

注：  
? 字符串str以 ‘\\0’ 作为**结束标志**，strlen函数返回的是在字符串中 ‘\\0’ 前面出现的字符个数（不包含 ‘\\0’ ）。

? 参数指向的字符串必须要以 **‘\\0’** 结束。  
如果没有 ‘\\0’ 结尾，长度会一直计算下去，直到遇到 ‘\\0’ 。

? 注意函数的**返回值**为size\_t，是**无符号**的。

### 1.1 模拟实现 ###

#include<stdio.h>
    size_t my_strlen(const char* str)
    {
        
    	int count = 0;
    	while (*str != '\0')//终止条件
    	{
        
    		count++;//累计 计算字符串长度
    		str++;
    	}
    	return count;
    }
    
    int main()
    {
        
    	size_t sz = my_strlen("abc");//无符号类型
    	printf("%u\n", sz);//打印无符号十进制整型
    	return 0;
    }

## 2. strcpy函数 ##

**功能：** 复制字符串

char * strcpy ( char * destination, const char * source );
    
    //destination(目的地)--指向要在其中复制内容的目标数组的指针
    //source(源)--要复制的字符串

将源指向的字符串复制到目标指向的数组中，包括终止的 ‘\\0’ 字符（**并在该点停止**）。

为避免溢出，目标指向的数组的大小应足够长，以包含与源相同的字符串（包括终止空字符），并且**不应在内存中与源重叠**。

? **实例1：**

#include <stdio.h>
    #include<string.h>
    int main()
    {
        
    	char str1[] = "Sample string";
    	char str2[40];
    	char str3[40];
    	strcpy(str2, str1);//将str1拷贝到str2
    	strcpy(str3, "copy successful");
    	printf("str1: %s\nstr2: %s\nstr3: %s\n", str1, str2, str3);
    	return 0;
    }

? 运行结果：

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

? **实例2：**

#include <stdio.h>
    #include<string.h>
    int main()
    {
        
    	char arr1[] = "xxxxxxxxxx";
    	char arr2[5] = {
         'a', 'b', 'c', 'd', 'e' };
    	strcpy(arr1, arr2);//将 arr2 里的东西拷贝到 arr1 中
    	printf("%s\n", arr1);
    	return 0;
    }

? 运行结果：  
![在这里插入图片描述][cb6ce9074b0f4980a10d299ec10d0257.png]

为什么结果不是 abcde 呢？  
我们在调试时，打开监视窗口观察arr1的变化，虽然 abced 已拷贝给 arr1， 但没有发现结束标志，所以在创建 arr2 时，要在最后加上 ‘\\0’  
![在这里插入图片描述][7adab455d46348948c7e462858c68546.png]![在这里插入图片描述][d68d85f16ed04d03a33ba78213b3d47e.png]  
**添加了结束标志的 arr2 ：**  
![在这里插入图片描述][0af7ca02f5d94a71a5e60c2282d2e933.png]

注：  
? 源字符串必须以 ‘\\0’ 结束。

? 会将源字符串中的 ‘\\0’ 拷贝到目标空间。

? 目标空间必须足够大，以确保能存放源字符串。

? 目标空间必须可变。

### 2.1 模拟实现 ###

#include<stdio.h>
    #include<assert.h>
    char* my_strcpy(char* dest, const char* src)
    {
        
    	char* ret = dest;
    	assert(dest != NULL);//若字符串为空，就停止运行，并提示
    	assert(src != NULL);
    
    	while (*src != '\0')
    	{
        
    		*dest = *src;//实现拷贝
    		dest++;//后移一个字符
    		src++;
    	}
    	*dest = *src;// '\0'
    
    	return ret;
    }
    
    int main()
    {
        
    	char arr1[20] = "hello world";
    	char arr2[] = "xxxxx";
    	my_strcpy(arr1 + 6, arr2);//从arr1的第六个字符之后开始拷贝arr2
    	printf("%s\n", arr1);
    	return 0;
    }

? 运行结果：

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

`?补充：`

assert(表达式)--表达式为真时, 程序继续运行, 如果表达式为假, 那程序就会停止运行, 并提示错误信息

## 3. strcat函数 ##

**功能：** 连接字符串

char * strcat ( char * destination, const char * source );
    
    //destineion--指向目标数组的指针，该数组应包含字符串，并且足够大以包含串联的结果字符串
    //source--要追加的字符串

将源字符串的副本**追加到**目标字符串。  
目标中的**终止空字符**被源的**第一个字符**覆盖，并且在目标中由两者串联形成的新字符串的**末尾包含一个空字符**。

目的地和来源不得重叠。

? **实例：**

#include <stdio.h>
    #include <string.h>
    int main()
    {
        
    	char str1[100]="hello ";
    	char str2[] = "world";
    	printf("%s\n", strcat(str1, str2));
    	return 0;
    }

? 运行结果：

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

注：  
? 源字符串必须以 ‘\\0’ 结束。

? 目标空间必须有足够的大，能容纳下源字符串的内容。

? 目标空间必须可修改。

### 3.1 模拟实现 ###

#include<stdio.h>
    char* my_strcat(char*dest, const char *src)
    {
        
    	assert(dest && src);
    	char* ret = dest;
    	//1. 找目标空间中的\0
    	while (*dest)
    	{
        
    		dest++;
    	}
    	while (*dest++ = *src++)//实现拷贝
    	{
        
    		;
    	}
    	return ret;
    }
    
    int main()
    {
        
    	char arr1[20] = "hello ";
    	char arr2[] = "world";
    	my_strcat(arr1, arr2);
    	printf("%s\n", arr1);
    	return 0;
    }

## 4. strcmp函数 ##

**功能：** 比较两个字符串

int strcmp ( const char * str1, const char * str2 );

将字符串 str1 与字符串 str2 进行比较。

**开始**比较每个字符串的第一个字符。如果它们**彼此相等**，则继续以下对，**直到**字符不同或达到终止空字符。

此函数执行字符的二进制比较。

标准规定：  
? 第一个字符串大于第二个字符串，则**返回大于0**的数字

? 第一个字符串等于第二个字符串，则**返回0**

? 第一个字符串小于第二个字符串，则**返回小于0的数字**

? **实例1：**

#include<stdio.h>
    #include<string.h>
    int main()
    {
        
    	printf("%d\n", strcmp("bbq","bcq"));
    	return 0;
    }

? 运行结果：  
\-1

? **实例2：猜动物**

#include<stdio.h>
    #include<string.h>
    int main()
    {
        
        char str1[] = "dog";
        char str2[80];
        do {
        
            printf("Guess my favorite animal? ");
            scanf("%s", str2);
        } while (strcmp(str1, str2) != 0);
        puts("Correct answer!");
        return 0;
    }

? 运行结果：

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

### 4.1 模拟实现 ###

int my_strcmp(const char* str1, const char* str2)
    {
        
    	assert(str1 && str2);
    
    	while (*str1 == *str2)
    	{
        
    		if (*str1 == '\0')
    			return 0;
    		str1++;//后移
    		str2++;
    	}
    
    	return (*str1 - *str2);
    }
    
    int main()
    {
        
    	int ret = my_strcmp("bbq", "bcq");
    	if (ret>0)
    		printf(">\n");
    	printf("%d\n", ret);//-1
    	return 0;
    }

## 5. strncpy函数 ##

**功能：** 从字符串中复制字符

char * strncpy ( char * destination, const char * source, size_t num );
    
    //destination--指向要在其中复制内容的目标数组的指针。
    //source--要复制的 C 字符串。
    //num--要从源复制的最大字符数。
    //size_t 是无符号整数类型。

**拷贝num个字符**从源字符串到目标空间。

如果源字符串的长度小于 num，则拷贝完源字符串之后，在目标的后边**追加0**，直到 num个。

? **实例：**

#include <stdio.h>
    #include <string.h>
    int main()
    {
        
    	char str1[] = "To be or not to be";
    	char str2[40];
    	char str3[40];
    	strncpy(str2, str1, sizeof(str2));
    	strncpy(str3, str2, 5);
    	str3[5] = '\0';   
    	puts(str1);//打印字符串
    	puts(str2);
    	puts(str3);
    	return 0;
    }

? 运行结果：

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

### 5.1 模拟实现 ###

#include<stdio.h>
    #include<assert.h>
    char* my_strncpy(char* dest, const char* sou, size_t num)
    {
        
    	char* ret = dest;
    	assert(dest != NULL);
    	assert(sou != NULL);
    	for (int i = (int)num; i > 0; i--)
    		*dest++ = *sou++;
    	return ret;
    }
    int main()
    {
        
    	char str1[20] = "abcdef";
    	char str2[] = "xxx";
    	my_strncpy(str1, str2, sizeof(str1));
    	puts(str1);
    	return 0;
    }

? 运行结果：  
xxx  
![在这里插入图片描述][5f3062af011648d2a92a3f4cac080415.png]

## 6. strncat函数 ##

**功能：** 从字符串追加字符

char * strncat ( char * destination, const char * source, size_t num );
    
    //destination--指向目标数组的指针，该数组应包含一个字符串，并且足够大以包含串联的结果字符串，包括其他 null 字符。
    //source--要追加的 C 字符串。
    //num--要追加的最大字符数。
    //size_t是无符号整数类型。

将源的第一个数字字符**追加**到目标，外加一个终止空字符。

如果源中 C 字符串的长度小于 num，则仅复制终止空字符之前的内容。

? **实例1：**

#include <stdio.h>
    #include <string.h>
    int main ()
    {
        
      char str1[20];
      char str2[20];
      strcpy (str1,"To be ");
      strcpy (str2,"or not to be");
      strncat (str1, str2, 6);//将str2的前6个字符追加给str1后面
      puts (str1);//To be or not
      return 0;
    }

? 运行结果：  
![在这里插入图片描述][637d727f0f00470d9d5079ff1a83535f.png]  
? **实例2：**

int main()
    {
        
    	char arr1[20] = "abcdef\0yyyyyyyy";
    	char arr2[] = "xxxxxxxxx";
    	strncat(arr1, arr2, 3);
    	puts(arr1);//abcdefxxx
    	return 0;
    }

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

`?说明了，遇到了结束标志 '\0' 就开始复制源代码`

### 6.1 模拟实现 ###

#include <stdio.h>
    #include<assert.h>
    char* my_strncat(char* dest, const char* soc, size_t num)
    {
        
    	char* ret = dest;
    	int i=0;
    	int count = 0;
    	assert(dest != NULL);
    	assert(soc != NULL);
    	while (*dest != '\0')
    	{
        
    		dest++;
    	}
    	while (num--)//终止条件：复制的个数num
    		*dest++ = *soc++;//追加
    	*dest = '\0';
    	return ret;
    }
    int main()
    {
        
    	char arr1[20] = "abcdef\0yyyyyyyy";
    	char arr2[] = "xxxxxxxxx";
    	my_strncat(arr1, arr2, 3);
    	puts(arr1);//abcdefxxx
    	return 0;
    }

? 运行结果：

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

## 7. strncmp函数 ##

**功能:** 比较两个字符串的字符

int strncmp ( const char * str1, const char * str2, size_t num );

将字符串 str1 的字符数与字符串 str2 的字符数进行比较。

此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续使用以下对，直到字符不同，直到达到终止的空字符，或者直到两个字符串中的 num 字符匹配，以先发生者为准。

标准规定：

? 第一个不匹配的字符在 str1 中的值大于在 str2 中的值，则**返回大于0的数字**

? 两个字符串的内容相等，则**返回0**

? 不匹配的第一个字符在 str1 中的值低于 str2 中的值，则**返回小于0的数字**

? **实例：**

//代码1
    #include <stdio.h>
    #include<string.h>
     int main()
    {
        
    	char arr1[] = "abcioxjnjj";
    	char arr2[] = "abcdef";
    	printf("%d\n", strncmp(arr1, arr2, 4));//1
    	return 0;
    }
    
    //代码2：
     int main()
    {
        
    	char arr1[] = "abcdoxjnjj";
    	char arr2[] = "abcdef";
    	printf("%d\n", strncmp(arr1, arr2, 4));//0
    	return 0;
    }

### 7.1 模拟实现 ###

strncmp 函数与 strcmp 函数相似，不过它是比较两个字符串的前n个字符，它比较结束的标志是比较出来前n个字符的不同或者直到 ’\\0’ 为止。

#include<stdio.h>
    #include<assert.h>
    int my_strncmp(const char* str1, const char* str2, size_t num)
    {
        
        assert(str1 != NULL);
        assert(str2 != NULL);
        while (num && *str1 && *str2)
        {
        
            if (*str1 > *str2)
            {
        
                return 1;
            }
            if (*str1 < *str2)
            {
        
                return -1;
            }
            else
            {
        
                return 0;
            }
            num--;
            str1++;
            str2++;
        }
        return 0;
    }
    int main()
    {
        
        char* str1 = "abcdoxjnjj";
        char* str2 = "abcdef";
        int ret = my_strncmp(str1, str2, 4);
        printf("%d\n", ret);
        return 0;
    }

? 运行结果：  
0

## 8. strstr函数 ##

**功能：** 查找子字符串

const char * strstr ( const char * str1, const char * str2 );
    
    //str1--要扫描的字符串。
    //str2--包含要匹配的字符序列的字符串

返回指向 str2 中第一次出现的 str1 的指针，如果 str2 不是 str1 的一部分，则返回一个**空指针**。  
匹配过程不包括终止空字符，但它到此为止。

? **实例：**

#include <stdio.h>
    #include <string.h>
    int main()
    {
        
    	char arr1[] = "abbbcdef";
    	char arr2[] = "bbc";
    	char* ret = strstr(arr1, arr2);
    	if (ret != NULL)
    		printf("%s\n", ret);
    	else
    		printf("找不到\n");
    
    	return 0;
    }

? 运行结果：

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

### 8.1 模拟实现 ###

#include <stdio.h>
    char* my_strstr(char* str1, char* str2)
    {
        
    	char* cp = str1;
    	char* s1 = cp;
    	char* s2 = str2;
    
    	if (*str2 == '\0')
    		return str1;
    	while (*cp)
    	{
        
    		//开始匹配
    		s1 = cp;
    		s2 = str2;
    		while (*s1 && *s2 && *s1 == *s2)
    		{
        
    			s1++;
    			s2++;
    		}
    		if (*s2 == '\0')
    			return cp;
    
    		cp++;
    	}
    
    	return NULL;
    }
    
    int main()
    {
        
    	char arr1[] = "abbbcdef";
    	char arr2[] = "bbc";
    
    	char* ret = my_strstr(arr1, arr2);
    	if (ret != NULL)
    		printf("%s\n", ret);
    	else
    		printf("找不到\n");
    
    	return 0;
    }

## 9. strtok函数 ##

**功能：** 将字符串拆分为标记

char * strtok ( char * str, const char * delimiters );

*  sep 参数是个字符串，定义了用作分隔符的字符集合。
 *  第一个参数指定一个字符串，它包含了0个或者多个由 sep 字符串中一个或者多个分隔符分割的标记。
 *  strtok函数找到str中的下一个标记，并将其用 \\0 结尾，返回一个指向这个标记的指针。

（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改）

? **实例：**

#include<string.h>
    #include <stdio.h>
    int main()
    {
        
    	char* p = "woaiCyuyan.com/cn";
    	const char* sep = "./";
    	char arr[30];
    	char* str = NULL;
    	strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
    	for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
    	{
        
    		printf("%s\n", str);
    	}
    	return 0;
    }

? 运行结果：

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

## 10. strerror函数 ##

**功能：** 返回错误码，所对应的错误信息

char * strerror ( int errnum );

? **实例：**

#include <stdio.h>
    #include<string.h>
    #include <errno.h>//必须包含的头文件
    int main()
    {
        
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
        
    		printf("%d: %s\n", i, strerror(i));
    	}
    	return 0;
    }

? 运行结果：  
![在这里插入图片描述][fb7671f0565f42ec945c7e8bd0e71912.png]

## 11.memcpy函数 ##

**功能：** 复制内存块

void * memcpy ( void * destination, const void * source, size_t num );
    
    //destination--指向要在其中复制内容的目标数组的指针，类型转换为 void* 类型的指针。
    //source--指向要复制的数据源的指针，类型转换为 const void* 类型的指针。
    //num--要复制的字节数。
    //size_t 是无符号整数类型。

? 函数 memcpy 从 source 的位置开始向后复制 num 个字节的数据到destination的内存位置。

? 这个函数在遇到 ‘\\0’ 的时候并不会停下来。

? 如果 source 和 destination 有任何的重叠，复制的结果都是未定义的。

? **实例：**

#include <stdio.h>
    #include <string.h>
    struct {
        
    	char name[40];
    	int age;
    } person, person_copy;
    int main()
    {
        
    	char myname[] = "peter";
    	memcpy(person.name, myname, strlen(myname) + 1);
    	person.age = 46;
    	memcpy(&person_copy, &person, sizeof(person));
    	printf("person_copy: %s, %d \n", person_copy.name, person_copy.age);
    	return 0;
    }

? 运行结果：  
![在这里插入图片描述][df58263e9d6b4522aa82c2b32458843c.png]

## 12. memmove函数 ##

**功能：** 移动内存块，将字节数的值从源指向的位置复制到目标指向的内存块

void * memmove ( void * destination, const void * source, size_t num );

? 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

? 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

? **实例：**

#include <stdio.h>
    #include <string.h>
    int main ()
    {
        
      char str[] = "i love C";
      memmove(str , str +2, 3);
      //从l开始的三个字符(lov)移动到str中，且覆盖了str原来的前三个字符
      puts (str);
      return 0;
    }

? 运行结果：

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

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

## 结束语 ##

有关字符(串)的函数还有很多，我们还需要勤加练习，慢慢消化。  
　　加油＾＿＾  
　　我们下一篇文章再见。  
![在这里插入图片描述][d54b127b0c3845bf9751ec1b4ca845c1.png]

[Link 1]: https://blog.csdn.net/iLoyo_?spm=1010.2135.3001.5421
[620fbdefcc2f4ceebacd975da3d5fd6a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/de2ac0703a5641429fe44d16a38e6b5d.png
[53a831ff9d874b0e807f84595e252b4c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/a11bbb7f549744e8986e72dc7617a23c.png
[d5238272233e4cbcaa6d46f58a48d92f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/e16b42d7521e47779992a7f086e2eac1.png
[4dd920f3b19b45af896170eb9f2ab929.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/399826b108714cfc91dc6ff4c140ddc6.png
[cb6ce9074b0f4980a10d299ec10d0257.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/c8662139f464479eb06d34bb028090a5.png
[7adab455d46348948c7e462858c68546.png]: https://img-blog.csdnimg.cn/7adab455d46348948c7e462858c68546.png
[d68d85f16ed04d03a33ba78213b3d47e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/e6809cd5cacd474b8144df7e36d7d1f8.png
[0af7ca02f5d94a71a5e60c2282d2e933.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/b25e0c73f54e46d388a3354174b663bc.png
[3ae237eef3904e15b80b2cee73cde060.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/1a70062c50bf4aaaac335070f0c59cb3.png
[c5155fe0ba13417c87797574991f8670.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/91b30e4d92154c92bc3c372687f5f816.png
[832c4e5055f44f9fa613ea3213f065fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/82d4f1d1a5b645b589cf088f98864dca.png
[9371631997a7454286cd8ce72aa61fd7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/159e30373dd240898f42b2b170f8fe10.png
[5f3062af011648d2a92a3f4cac080415.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/0488c067d2334c44920fdbb7b80f94e6.png
[637d727f0f00470d9d5079ff1a83535f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/e4d55aab5f3f4f4fb755e2fa52b24b87.png
[4b4a29d0a4354b2c94d482a380eb65d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/9dcfe664b9dc442a972b6ac97fd644b2.png
[9efdcd0730c14eff9f1d7264a6a8ae8e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/7e111f32b4204e1a80031b81c9a4820b.png
[d3b804bf9bd3436583b215beaa1d03da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/a90f9e04193b4e8d8af8d80597400379.png
[771ee99723104568801d5b84b3e9b29e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/0ebd5f74b2694f63a17aa56790ef9cca.png
[fb7671f0565f42ec945c7e8bd0e71912.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/557915b7a8ce4fca974d000d62d2e94f.png
[df58263e9d6b4522aa82c2b32458843c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/40ccfa87df9a49c8817e7e59d8386d93.png
[9a8a5fd81eb64db9a2a9f41a643119d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/46dcfce33a6b485c8cd73d9787cfc23c.png
[d54b127b0c3845bf9751ec1b4ca845c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/7d88125ea48c423d96ec18c98da2c19c.png