一篇博客学会系列（1） —— C语言中所有字符串函数以及内存函数的使用和注意事项

た入场券 2023-10-16 13:54 10阅读 0赞

**目录**

1、求字符串长度函数

1.1、strlen

2、字符串拷贝(cpy)、拼接(cat)、比较(cmp)函数

2.1、长度不受限制的字符串函数

2.1.1、strcpy

2.1.2、strcat

2.1.3、strcmp

2.2、长度受限制的字符串函数

2.2.1、strncpy

2.2.2、strncat

2.2.3、strncmp

3、字符串查找函数

3.1、strstr

3.2、strtok

4、错误信息报告函数

4.1、strerror

4.2、perror

5、字符函数

5.1、字符分类函数

5.2、字符转换函数

5.2.1、tolower

5.2.2、toupper

6、内存操作函数

6.1、memcpy

6.2、memmove

6.3、memset

6.4、memcmp

![341c30dcb8b54780a55b058f484502a5.gif][]

## 1、求字符串长度函数 ##

#### 1.1、strlen ####

![650fe58177eb4ed88b3833c848712d37.png][]

>  *  **strlen用于求字符串长度。**
>  *  包含头文件**<string.h>。**
>  *  字符串已经 '\\0' 作为结束标志，strlen函数返回的是在字符串中 '\\0' 前面出现的字符个数（不包含 '\\0' )。
>  *  参数指向的字符串**必须要以 '\\0' 结束**。
> 
> **注意：**
> 
> 1、函数的返回值为size\_t，是**无符号**的**（ 易错 ）**
> 
> 2、因为strlen返回的是 '\\0' 前面的字符个数，如果字符串中间本身就一个'\\0'，那么返回的值就会返回字符串中的'\\0'之前的字符个数。
> 
> 例如："abc**\\0**def" 这个字符串，使用strlen函数会返回3。

【使用方式】

int main()
    {
    	char arr[] = "Hello hacynn";
    	int ret = strlen(arr);
    	printf("%d\n", ret);
    	return 0;
    }

【运行结果】

![8077ead7596d422cb69b20a5580bc42f.png][]

**【易错提醒】**

请问ret的值是多少?
    int ret = strlen("abc") - strlen("abcdef");

> 答案是3，因为函数的返回值为size\_t，是无符号的整型。

【模拟实现strlen】

int my_strlen(char* arr)
    {
    	int count = 0;
    	while (*arr != '\0')
    	{
    		count++;
    		arr++;
    	}
    	return count;
    }
    
    int main()
    {
    	char arr[] = "Hello hacynn";
    	int ret = my_strlen(arr);
    	printf("%d\n", ret);
    	return 0;
    }

## 2、字符串拷贝(cpy)、拼接(cat)、比较(cmp)函数 ##

### 2.1、长度不受限制的字符串函数 ###

#### 2.1.1、strcpy ####

![bb878753ce744f04b82ea578870bff37.png][]

>  *  **strcpy用于拷贝字符串，将字符串2拷贝到字符串1当中。**
>  *  包含头文件**<string.h>。**
>  *  源字符串必须以 '\\0' 结束。
>  *  会将源字符串中的 '\\0' 拷贝到目标空间。
>  *  目标空间必须足够大，以确保能存放源字符串。
>  *  目标空间必须可变。

【使用方法】

int main()
    {
    	char arr1[] = "Hello hacynn";
    	char arr2[20] = { 0 };
    	strcpy(arr2,arr1);
    	printf("%s\n", arr2);
    	return 0;
    }

【运行结果】

![763bb70e24fb4b5daa4578f6dd688682.png][]

【模拟实现strcpy】

char* my_strcpy(char* dest,const char* src)
    {
    	char* ret = dest;
    	while (*dest = *src)
    	{
    		dest++;
    		src++;
    	}
    	return ret;
    }
    
    int main()
    {
    	char arr1[] = "Hello hacynn";
    	char arr2[20] = { 0 };
    	my_strcpy(arr2,arr1);
    	printf("%s\n", arr2);
    	return 0;
    }

#### 2.1.2、strcat ####

![ebaf75204c1b4b0fbb2f0e1dbf64c4dc.png][]

>  *  **strcat用于拼接两个字符串，将字符串2拼接到字符串1末尾。**
>  *  包含头文件**<string.h>。**
>  *  源字符串必须以 '\\0' 结束（保证找得到目标空间的末尾），在拷贝时会把源字符串的 '\\0 '也拷贝过去。
>  *  目标空间必须有足够的大，能容纳下源字符串的内容，并且还可以被修改。
> 
> **注意：**
> 
> 不能字符串自己追加自己，因为当自己追加自己的时候，追加的过程中会将目标字符串的 '\\0' 覆盖掉，而有因为此时目标字符串就是源字符串，就会导致源字符没有 '\\0' ，将会一直拼接下去导致死循环。
> 
> 虽然有些环境中该函数可以完成自己拼接自己，但是**C语言的标准中并未规定**strcat可以自己拼接自己，所以这个函数最好不要使用在自己拼接自己的情况下。如果真有自己追加自己的场景，建议使用**strncat函数**，这个函数将在下文进行讲解。

【使用方式】

int main()
    {
    	char arr1[20] = "Hello ";
    	char arr2[] = "hacynn" ;
    	strcat(arr1, arr2);
    	printf("%s\n", arr1);
    	return 0;
    }

【运行结果】

![a5242edf49944998a0d5f32cbaaad218.png][]

【模拟实现strcat】

char* my_strcat(char* dest, const char* src)
    {
    	char* ret = dest;
        //找到目标空间的末尾
    	while (*dest != '\0')
    	{
    		dest++;
    	}
        //数据追加
    	while (*dest = *src)
    	{
    		dest++;
    		src++;
    	}
    	return ret;
    }
    
    int main()
    {
    	char arr1[20] = "Hello ";
    	char arr2[] = "hacynn" ;
    	my_strcat(arr1, arr2);
    	printf("%s\n", arr1);
    	return 0;
    }

#### 2.1.3、strcmp ####

![961509d4b7724b13872a715b600c605a.png][]

>  *  **strcmp用于比较两个字符串。**
>  *  包含头文件**<string.h>。**
>  *  **误区：该函数不是比较字符串长度的，而是比较对应位置上字符的大小（ASCII）。**
>  *  标准规定：  
>     第一个字符串**大于**第二个字符串，则返回**大于**0的数字  
>     第一个字符串**等于**第二个字符串，则返回0  
>     第一个字符串**小于**第二个字符串，则返回**小于**0的数字

![7964991d60314591bcb3f7701c39363f.png][]

【使用方式】

int main()
    {
    	char arr1[] = "abcdef";
    	char arr2[] = "abz";
    	if (strcmp(arr1, arr2) > 0)
    		printf(">\n");
    	else
    		printf("<=\n");	
    	return 0;
    }

【运行结果】

![43275b676e4841c09035fe49715d6694.png][]

【模拟实现strcmp】

int my_strcmp(const char* str1, const char* str2)
    {
    	while (*str1 == *str2)
    	{
    		if (*str1 == '\0')
    			return 0;
    		str1++;
    		str2++;
    	}
    	if (*str1 > *str2)
    		return 1;
    	else
    		return -1;
    }
    
    int main()
    {
    	char arr1[] = "abcdef";
    	char arr2[] = "abz";
    	if (my_strcmp(arr1, arr2) > 0)
    		printf(">\n");
    	else
    		printf("<=\n");	
    	return 0;
    }

### 2.2、长度受限制的字符串函数 ###

>  *  就是可以限制操作个数的字符串函数。
>  *  包含头文件**<string.h>。**

#### 2.2.1、strncpy ####

![8615af463343417485670f7a06de462c.png][]

>  *  **区别仅与strcpy差一个参数，记录要操作的个数。** 
>  *  拷贝num个字符从源字符串到目标空间。
>  *  如果**源字符串的长度小于num**，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
>  *  因为拷贝个数由用户自己决定，因此\\0没有被拷贝过来的可能性也是有的。

【使用方式】

int main()
    {
    	char arr1[] = "Hello hacynn";
    	char arr2[20] = { 0 };
    	strncpy(arr2, arr1, 5); //拷贝前五个字符 ，此时拷贝\0后arr2中并不会有\0
    	printf("%s\n", arr2);
    	return 0;
    }

【运行结果】

![b967f7b00cf8445694b3540f9775052b.png][]

**【特殊情况】**

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

int main()
    {
    	char arr1[] = "Hello";
    	char arr2[20] = "xxxxxxxxxxxxxxxxx";
    	strncpy(arr2, arr1, 10);   //此时10大于arr1的元素个数，就会在后添加0直至够10个
    	printf("%s\n", arr2);
    	return 0;
    }

![b474ecea8e7548c0964c3225c6422548.png][]

#### 2.2.2、strncat ####

![ff44e4cb18a2472992b248c292550895.png][]

>  *  **区别也仅与strcat差一个参数，记录要操作的个数。**
>  *  使用strncat追加，当结束追加时，就算没到\\0，也会在末尾追加一个\\0。
>  *  如果**源字符串的长度小于num**，则追加完源字符串之后，会自动停止追加。**注意此处与strncpy的区别。**
>  *  包含头文件**<string.h>。**

【使用方式】

int main()
    {
    	char arr1[20] = "Hello ";
    	char arr2[] = "hacynn" ;
    	strncat(arr1, arr2, 3);
    	printf("%s\n", arr1);
    	return 0;
    }

【运行结果】

![ee4be7629ecd4d2ab42c6636ddde7787.png][]

#### 2.2.3、strncmp ####

![50a61dbaf05a45bea14370035c791dec.png][]

>  *  **区别也仅与strcmp差一个参数，记录要操作的个数。**
>  *  包含头文件**<string.h>。**

【使用方式】

int main()
    {
    	char arr1[] = "abcdef";
    	char arr2[] = "abcz";
    	if (strncmp(arr1, arr2, 3) > 0)   //只比较前三个字符
    		printf(">\n");
    	else if (strncmp(arr1, arr2, 3) == 0)
    		printf("=\n");
    	else
    		printf("<\n");
    	return 0;
    }

【运行结果】

![1ebe05bb178844b3a46954ac62361b69.png][]

## 3、字符串查找函数 ##

#### 3.1、strstr ####

![21b95e2fff9e43a3a807d68ce7fd969d.png][]

>  *  查找一个字符串中是否存在与另一个字符串当中，即**找子串**。
>  *  返回一个指向str1中**第一个出现**str2的指针，如果str2不是str1的一部分，则返回一个空指针NULL。
>  *  包含头文件**<string.h>。**

【使用方式】

> 可以看到，即使是有两个字串 ，也只会返回第一次出现的地址。

int main()
    {
    	char arr1[] = "abcdefghidef";   //def出现了两次
    	char arr2[] = "def";
    	char* ret = strstr(arr1, arr2);
    	if (ret == NULL)
    		printf("找不到\n");
    	else
    		printf("%s\n", ret);
    	return 0;
    }

【运行结果】

![a29a15aea49e4cf594d3f994cf02ee3b.png][]

【模拟实现strstr】

const char* my_strstr(const char* str1, const char* str2)
    {
        if (*str2 == '\0')
    		return str1;
    	char* pc = str1;  //pc用于记录开始匹配的位置
    	while (*pc)
    	{
    		char* s1 = pc;   //遍历str1指向的字符串
    		char* s2 = str2; //遍历str2指向的字符串
    		while (*s1 && *s2 && (*s1 == *s2))
    		{
    			s1++;
    			s2++;
    		}
    		if (*s2 == '\0')
    			return pc;
    		pc++;
    	}
    	return NULL;
    }
    
    int main()
    {
    	char arr1[] = "abcdefghidef";
    	char arr2[] = "def";
    	char* ret = my_strstr(arr1, arr2);
    	if (ret == NULL)
    		printf("找不到\n");
    	else
    		printf("%s\n", ret);
    	return 0;
    }

【图解】

![7abbe9b3529444afbd45bbea02750c9c.png][]

#### 3.2、strtok ####

![6a07ab344b6641369879b3079f609b52.png][]

>     比较奇葩的一个函数
>     char * strtok ( char * str, const char * delimiters );

>  *  **切割字符串函数，例如hacynn@nash.com，当切割标记是@和 . 时，通过三次合理的使用可以切割出三个字符串：hacynn nash com**
>  *  包含头文件**<string.h>。**
>  *  delimiters参数是个**字符串**，定义了用作分隔符的**字符集合**。
>  *  第一个参数指定一个字符串，它包含了0个或者多个由delimiters字符串中一个或者多个分隔符分割的标记。
>  *  strtok函数找到str中的下一个标记，并将其用 \\0 结尾，返回一个指向这个标记的指针。（注：strtok函数**会改变被操作的字符串**，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
>  *  strtok函数的第一个参数**不为 NULL** ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
>  *  strtok函数的第一个参数**为 NULL** ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
>  *  如果字符串中不存在更多的标记，则返回 NULL 指针

【使用方式】

int main()
    {
    	char arr[] = "hacynn@nash.com";
    	char buf[200] = { 0 }; //因为strtok会改变被操作字符串，
    	                        //所以拷贝一个临时变量来操作
    	strcpy(buf, arr);
    	char* p = "@.";
    	char* s = strtok(buf, p); //参数不为NULL，找到第一个标记
    	printf("%s\n", s);
    
    	s = strtok(NULL, p); //参数为NULL，找到下一个标记
    	printf("%s\n", s);
    
    	s = strtok(NULL, p); 参数为NULL，找到下一个标记
    	printf("%s\n", s);
    
    	return 0;

【运行结果】

![492ccfd59a2f4a8eb5ee91207c44ba34.png][]

**【使用方式优化 】**

> 在实际开发中，我们不一定知道这个字符串是怎样的，这个字符串需要切割几次的，因此手动设置切割几次将代码写死的方式是不可取，而应该使用**以下的方式**进行自动切割。

int main()
    {
    	char arr[] = "hacynn@nash.com.hahaha@abcd";
    	char buf[200] = { 0 };
    	strcpy(buf, arr);
    	char* p = "@.";
    
    	char* s = NULL;
    	for (s = strtok(buf, p); s != NULL; s = strtok(NULL, p))
    	{
    		printf("%s\n", s);
    	}
    	
    
    	return 0;
    }

> 这里巧妙的运用了for函数的初始化部分只执行一次的特点，而strtok也只需要第一次传地址，其他时候都只需要传NULL就行。

**【优化后的运行结果】**

![adf14babae274d988fd55e2b8c7b0c17.png][]

## 4、错误信息报告函数 ##

#### 4.1、strerror ####

![6fc9f0860d934e6cbb241b2dad002abe.png][]

>  *  **strerror函数是将错误码翻译成错误信息，返回错误信息的字符串起始地址。**
>  *  包含头文件**<string.h>。**
>  *  C语言中使用库函数的时候，如果发生错误，就会将错误码放在errno的变量中，errno是一个 全局变量，可以直接使用。

【错误码举例】

int main()
    {
    	int i = 0;
    	for ( i = 0; i < 10; i++)
    	{
    		printf("%d: %s\n", i, strerror(i));
    	}
    	return 0;
    }

> 每一个错误码都对应一个错误信息

![6c069fb7eb38433ab3cb28b48407e520.png][]

【使用方式】

> 以打开文件为例子，fopen以读的形式打开文件，当文件存在时打开成功，文件不存在时打开失败，并返回空指针。可以利用这个来设置一个打开失败时的错误信息告知。

int main()
    {
    	FILE* pf = fopen("add.txt", "r");  //当前文件路径中并没有add.txt文件，打开失败
    	if (pf == NULL)
    	{
    		printf("打开文件失败，原因是：%s\n", strerror(errno));
    		return 1;
    	}
    	else
    	{
    		printf("打开文件成功\n");
    	}
    	return 0;
    }

【运行结果】

![fa5f6c1747b84049a30155c06affa224.png][]

#### 4.2、perror ####

![58a5f9489613499985c36162e0cf5043.png][]

>  *  perror也是用于翻译错误信息 ，但与strerror不同的是，perror会直接打印错误码所对应的错误信息。而perror中传递的字符串参数就是**自定义显示信息**的部分，打印的结果就是 **自定义显示信息：错误信息**
>  *  包含头文件**<stdlib.h>**
>  *  **可以简单理解为：perror = printf + strerror 即翻译又打印**

【使用方式】

int main()
    {
    	FILE* pf = fopen("add.txt", "r");
    	if (pf == NULL)
    	{
    		perror("打开文件失败");   //注意：此处是perror，不是printf。
    		return 1;
    	}
    	else
    	{
    		printf("打开文件成功\n");
    	}
    	return 0;
    }

【运行结果】

![1e8cb4388d684332b85b60c89dc81138.png][]

## 5、字符函数 ##

### 5.1、字符分类函数 ###

> 字符分类函数使用**非常简单**，由于篇幅受限，在这里不就一一列举了 ，只需要把下面的图看懂就行。

![3f1ee15c397a455db9bad1f442818304.png][]

### 5.2、字符转换函数 ###

#### 5.2.1、tolower ####

![308437e0e4af4c519852255b5cd47fbf.png][]

> 这个函数听名字就知道是用于将大写字母转换成小写字母，而这类函数唯一需要注意的就是函数有返回值，**返回类型为int**，因此在使用的时候最好使用一个int ret接收返回值。

int main()
    {
    	int ret = tolower('A');
    	printf("%c\n", ret);
    }

#### 5.2.2、toupper ####

![c4706573bde6444fa3609d509db33832.png][]

> 小写字母转大写字母，其他注意点与tolower一致。

## 6、内存操作函数 ##

> 上文讲到的**字符串函数只适用于字符串**，但是内存中的数据不仅仅只有字符，这就导致这些函数有很大的局限性。因此需要有一个能够对所有类型的数据都适用的函数，这就是内存操作函数的出现的原因。下面我们来学习一下内存操作函数。

#### 6.1、memcpy ####

![30ef2d41c79142f2b65728e1501d7746.png][]

>  *  **函数memcpy从source的位置开始向后拷贝num个字节的数据到destination的内存位置。**
>  *  包含头文件**<string.h>**
>  *  这个函数在遇到 '\\0' 的时候并不会停下来。
>  *  如果source和destination有任何的重叠，复制的结果都是**未定义**的。
>  *  因为**C语言标准中并未规定**memcpy能适用于重叠内存的拷贝，因此**不重叠**内存的拷贝才使用memcpy，而**重叠**内存的拷贝使用**接下来讲解的memmove函数。**

【使用方式】

> 使用memcpy拷贝整型数据。

int main()
    {
    	int arr1[10] = { 0 };
    	int arr2[] = { 1,2,3,4,5 };
    	memcpy(arr1, arr2, sizeof(int) * 5);
    	int i = 0;
    	for ( i = 0; i < 5; i++)
    	{
    		printf("%d ", arr1[i]);
    	}
    	return 0;
    }

【运行结果】

![d702a4cac45844dbbb33cc6c44ad8b79.png][]

【模拟实现memcpy】

void* my_memcpy(void* dest, const void* src, size_t sz)
    {
    	void* ret = dest;
    	while (sz)
    	{
    		*(char*)dest = *(char*)src;
    		dest = (char*)dest + 1;
    		src = (char*)src + 1;
    		sz--;
    	}
    	return ret;
    }
    
    int main()
    {
    	int arr1[10] = { 0 };
    	int arr2[] = { 1,2,3,4,5 };
    	my_memcpy(arr1, arr2, sizeof(int) * 5);
    	int i = 0;
    	for ( i = 0; i < 5; i++)
    	{
    		printf("%d ", arr1[i]);
    	}
    	return 0;
    }

#### 6.2、memmove ####

![710dae73d3df4bdbbfc6134fc6d2880c.png][]

>  *   **memmove的参数和功能与memcpy完全一致。**
>  *  包含头文件**<string.h>**
>  *  唯一有区别的就是memmove函数处理的源内存块和目标内存块是**可以重叠**的。
>  *  因此当出现重叠内存的拷贝时，就使用memmove函数处理。

【模拟实现memmove】

void* my_memmove(void* dest, const void* src, size_t sz)
    {
    	void* ret = dest;
    	if (dest < src)
    	{
    		while (sz)
    		{
    			*(char*)dest = *(char*)src;
    			dest = (char*)dest + 1;
    			src = (char*)src + 1;
    			sz--;
    		}
    	}
    	else
    	{
    		while (sz--)
    		{
    			*((char*)dest + sz) = *((char*)dest + sz);
    		}
    	}
    	return ret;
    }
    
    int main()
    {
    	int arr1[] = { 1,2,3,4,5 ,6,7,8,9,10 };
    	my_memmove(arr1, arr1+2, sizeof(int) * 5);
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		printf("%d ", arr1[i]);
    	}
    	return 0;
    }

#### 6.3、memset ####

![4a8e6d5554e4430db0a2fc8dc21500ad.png][]

>  *  **将ptr所指向空间的前num个字节设置为指定值value。**
>  *  包含头文件**<string.h>**

【使用方式】

int main()
    {
    	char arr[] = "hello world";
    	memset(arr + 6, 'x', 3);
    	printf("%s\n", arr);
    	return 0;
    }

【运行结果】

![33493cd2ea84495484c3bc45edcc26b5.png][]

#### 6.4、memcmp ####

![5b70f68784ec416cb9c5694ff079f7fc.png][]

>  *  **比较ptr1和ptr2前num个字节的内容。**
>  *  包含头文件**<string.h>**
>  *  标准规定：  
>     ptr1**大于**ptr2，则返回**大于**0的数字。  
>     ptr1**等于**ptr2，则返回0。  
>     ptr1**小于**ptr2，则返回**小于**0的数字。

![79656184674840eba7192829276bc94e.png][] 【使用方式】

int main()
    {
    	int arr1[] = { 1,2,3,4,5,6,7 };
    	int arr2[] = { 1,2,3,7 };
    	int ret = memcmp(arr1, arr2, sizeof(int) * 3);
    	printf("%d\n", ret);
    }

【运行结果】

![733ff0017cf74d299ae481dfb8cf4a8b.png][]

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

**如果觉得作者写的不错，求给博主一个大大的点赞支持一下，你们的支持是我更新的最大动力！**

[341c30dcb8b54780a55b058f484502a5.gif]: https://img-blog.csdnimg.cn/341c30dcb8b54780a55b058f484502a5.gif
[650fe58177eb4ed88b3833c848712d37.png]: https://img-blog.csdnimg.cn/650fe58177eb4ed88b3833c848712d37.png
[8077ead7596d422cb69b20a5580bc42f.png]: https://img-blog.csdnimg.cn/8077ead7596d422cb69b20a5580bc42f.png
[bb878753ce744f04b82ea578870bff37.png]: https://img-blog.csdnimg.cn/bb878753ce744f04b82ea578870bff37.png
[763bb70e24fb4b5daa4578f6dd688682.png]: https://img-blog.csdnimg.cn/763bb70e24fb4b5daa4578f6dd688682.png
[ebaf75204c1b4b0fbb2f0e1dbf64c4dc.png]: https://img-blog.csdnimg.cn/ebaf75204c1b4b0fbb2f0e1dbf64c4dc.png
[a5242edf49944998a0d5f32cbaaad218.png]: https://img-blog.csdnimg.cn/a5242edf49944998a0d5f32cbaaad218.png
[961509d4b7724b13872a715b600c605a.png]: https://img-blog.csdnimg.cn/961509d4b7724b13872a715b600c605a.png
[7964991d60314591bcb3f7701c39363f.png]: https://img-blog.csdnimg.cn/7964991d60314591bcb3f7701c39363f.png
[43275b676e4841c09035fe49715d6694.png]: https://img-blog.csdnimg.cn/43275b676e4841c09035fe49715d6694.png
[8615af463343417485670f7a06de462c.png]: https://img-blog.csdnimg.cn/8615af463343417485670f7a06de462c.png
[b967f7b00cf8445694b3540f9775052b.png]: https://img-blog.csdnimg.cn/b967f7b00cf8445694b3540f9775052b.png
[b474ecea8e7548c0964c3225c6422548.png]: https://img-blog.csdnimg.cn/b474ecea8e7548c0964c3225c6422548.png
[ff44e4cb18a2472992b248c292550895.png]: https://img-blog.csdnimg.cn/ff44e4cb18a2472992b248c292550895.png
[ee4be7629ecd4d2ab42c6636ddde7787.png]: https://img-blog.csdnimg.cn/ee4be7629ecd4d2ab42c6636ddde7787.png
[50a61dbaf05a45bea14370035c791dec.png]: https://img-blog.csdnimg.cn/50a61dbaf05a45bea14370035c791dec.png
[1ebe05bb178844b3a46954ac62361b69.png]: https://img-blog.csdnimg.cn/1ebe05bb178844b3a46954ac62361b69.png
[21b95e2fff9e43a3a807d68ce7fd969d.png]: https://img-blog.csdnimg.cn/21b95e2fff9e43a3a807d68ce7fd969d.png
[a29a15aea49e4cf594d3f994cf02ee3b.png]: https://img-blog.csdnimg.cn/a29a15aea49e4cf594d3f994cf02ee3b.png
[7abbe9b3529444afbd45bbea02750c9c.png]: https://img-blog.csdnimg.cn/7abbe9b3529444afbd45bbea02750c9c.png
[6a07ab344b6641369879b3079f609b52.png]: https://img-blog.csdnimg.cn/6a07ab344b6641369879b3079f609b52.png
[492ccfd59a2f4a8eb5ee91207c44ba34.png]: https://img-blog.csdnimg.cn/492ccfd59a2f4a8eb5ee91207c44ba34.png
[adf14babae274d988fd55e2b8c7b0c17.png]: https://img-blog.csdnimg.cn/adf14babae274d988fd55e2b8c7b0c17.png
[6fc9f0860d934e6cbb241b2dad002abe.png]: https://img-blog.csdnimg.cn/6fc9f0860d934e6cbb241b2dad002abe.png
[6c069fb7eb38433ab3cb28b48407e520.png]: https://img-blog.csdnimg.cn/6c069fb7eb38433ab3cb28b48407e520.png
[fa5f6c1747b84049a30155c06affa224.png]: https://img-blog.csdnimg.cn/fa5f6c1747b84049a30155c06affa224.png
[58a5f9489613499985c36162e0cf5043.png]: https://img-blog.csdnimg.cn/58a5f9489613499985c36162e0cf5043.png
[1e8cb4388d684332b85b60c89dc81138.png]: https://img-blog.csdnimg.cn/1e8cb4388d684332b85b60c89dc81138.png
[3f1ee15c397a455db9bad1f442818304.png]: https://img-blog.csdnimg.cn/3f1ee15c397a455db9bad1f442818304.png
[308437e0e4af4c519852255b5cd47fbf.png]: https://img-blog.csdnimg.cn/308437e0e4af4c519852255b5cd47fbf.png
[c4706573bde6444fa3609d509db33832.png]: https://img-blog.csdnimg.cn/c4706573bde6444fa3609d509db33832.png
[30ef2d41c79142f2b65728e1501d7746.png]: https://img-blog.csdnimg.cn/30ef2d41c79142f2b65728e1501d7746.png
[d702a4cac45844dbbb33cc6c44ad8b79.png]: https://img-blog.csdnimg.cn/d702a4cac45844dbbb33cc6c44ad8b79.png
[710dae73d3df4bdbbfc6134fc6d2880c.png]: https://img-blog.csdnimg.cn/710dae73d3df4bdbbfc6134fc6d2880c.png
[4a8e6d5554e4430db0a2fc8dc21500ad.png]: https://img-blog.csdnimg.cn/4a8e6d5554e4430db0a2fc8dc21500ad.png
[33493cd2ea84495484c3bc45edcc26b5.png]: https://img-blog.csdnimg.cn/33493cd2ea84495484c3bc45edcc26b5.png
[5b70f68784ec416cb9c5694ff079f7fc.png]: https://img-blog.csdnimg.cn/5b70f68784ec416cb9c5694ff079f7fc.png
[79656184674840eba7192829276bc94e.png]: https://img-blog.csdnimg.cn/79656184674840eba7192829276bc94e.png
[733ff0017cf74d299ae481dfb8cf4a8b.png]: https://img-blog.csdnimg.cn/733ff0017cf74d299ae481dfb8cf4a8b.png