【C 语言进阶】一篇文章将你的 C 语言指针升华

清疚 2021-09-13 19:22 298阅读 0赞

### 文章目录 ###

*   *  1. 字符指针
     *   *  定义
         *  用法
     *  2. 指针数组
     *   *  定义
         *  用法
     *  3. 数组指针
     *   *  定义
         *  补充
         *  注意
         *  用法
     *  4. 数组传参和指针传参
     *   *  一维数组
         *  二维数组
         *  一级指针
         *  二级指针
         *  小结
     *  5. 函数指针
     *   *  定义
         *  用法
         *  注意
         *  练习
         *  小结
     *  6. 函数指针数组
     *   *  定义
         *  用法
     *  7. 指向函数指针数组的指针
     *   *  定义
         *  用法
     *  8. 回调函数
     *   *  定义
         *  用法
         *  补充（qsort函数）
     *  9.总结

指针的一些基础知识我已经在 [【初阶指针】][Link 1]这章总结过了，如果大家有些地方不清楚，可以点击链接回过去看一下。【初阶指针】了解后，我们了解了指针的概念：

> 1.  指针就是个变量，用来存放地址。地址可以唯一标识一块内存空间
> 2.  指针的大小是固定的4/8个字节（32位平台/64位平台）
> 3.  指针是有类型的。指针的类型决定了指针加减整数的步长，指针解引用操作时访问字节的大小
> 4.  指针的运算方式

而这章我们将更深入的探索指针的其他奥秘。

## 1. 字符指针 ##

### 定义 ###

> 字符指针是指向字符的指针，char\*

### 用法 ###

字符指针通有两种用法：

**用法一：指针指向一个字符**

#include <stdio.h>
    int main()
    { 
    	char ch = 'a';
    	char* pc = &ch;
    	*pc = 'm';
    	return 0;
    }

**用法二：指针指向一个字符串**

> 指针存入的是字符串首字符的地址

#include <stdio.h>
    int main()
    { 
    	char* pc = "hello world!";//将字符串首字符'h'地址放入pc
    
    	printf("%c\n", *pc);//结果为：h
    	printf("%s\n", pc);//结果为：hello world!
    	return 0;
    }

接下来看一个练习：

#include <stdio.h>
    int main()
    { 
    	char str1[] = "hello world!";
    	char str2[] = "hello world!";
    	const char* str3 = "hello world!";
    	const char* str4 = "hello world!";
    
    	if (str1 == str2)
    		printf("str1 and str2 are same\n");
    	else
    		printf("str1 and str2 are not same\n");
    	if(str3 == str4)
    		printf("str3 and str4 are same\n");
    	else
    		printf("str3 and str4 are not same\n");
    	return 0;
    }
    //结果为：
    //str1 and str2 are not same
    //str3 and str4 are same

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center]

## 2. 指针数组 ##

### 定义 ###

>  *  指针数组，本质还是数组
>  *  数组其实已经有整型数组，字符数组，而指针数组也是一样的，是**存放指针的数组**

int arr[10];//整型数组——存放整型的数组
    char ch[5];//字符数组——存放字符的数组
    
    //指针数组——存放指针的数组
    int* parr[5];//整型指针数组，有五个元素，每个元素是一个整形指针

### 用法 ###

**用法一：**

#include <stdio.h>
    int main()
    { 
    	int a = 10;
    	int b = 20;
    	int c = 30;
    	int* arr[3] = {  &a, &b, &c };
    	int i = 0;
    	for (i = 0; i < 3; i++)
    	{ 
    		printf("%d ", *arr[i]);
    	}
    	return 0;
    }

> 不推荐上面使用的方法，毕竟是多此一举啦

**用法二：**

#include <stdio.h>
    int main()
    { 
    	int a[5] = {  1,2,3,4,5 };
    	int b[5] = {  2,3,4,5,6 };
    	int c[5] = {  3,4,5,6,7 };
    	int* arr[3] = {  a,b,c };
    	int i = 0;
    	for (i = 0; i < 3; i++)
    	{ 
    		int j = 0;
    		for (j = 0; j < 5; j++)
    		{ 
    			printf("%d ", *(arr[i] + j));
    		}
    		printf("\n");
    	}
    	return 0;
    }

>  *  输出函数也可以写成：`printf("%d ", arr[i] [j]);`
>  *  如果不知道推导的可以去看看[初阶指针][Link 2]这章，在数组和地址的关系那部分有进行讲解

## 3. 数组指针 ##

### 定义 ###

> 数组指针，本质是指针，是指向数组的指针

### 补充 ###

>  *  一维数组arr的地址是：&arr，如果+1跳过的是整个数组大小
>  *  一维数组名arr一般是数组首元素的地址，等价于&arr\[0\]，如果+1，跳过的是一个元素的大小
>  *  二维数组数组名表示首元素地址，而二维数组首元素实则是第一行，并非第一个元素

#include <stdio.h>
    int main()
    { 
    	int arr[5] = {  1,2,3,4,5 };
    	int (*parr)[5] = &arr;
    	return 0;
    }

而如果将代码改成：`int *parr[5] = &arr;` 表示的还是数组指针吗？NO！

>  *  因为\[\]的优先级要高于 \* 号，所以必须加上（）来保证parr先和 \* 结合，只有 \* 和parr结合才能说明parr是一个指针。
>  *  而若不加\*，parr\[5\]结合，表示的是一个数组，故这里就是指针数组而不是数组指针

练习：将指向`double* a[5];`的指针写出来

double* (*pa)[5];

> 因为a\[5\]是一个数组，每个元素都是double\*类型，故是一个指针数组。指针为( \*pa )，而它指向的是一个数组( \*pa )\[5\]，而每个元素都是double \* 类型的，故结果为：`double* (*pa)[5];`

### 注意 ###

> 数组名一般是数组首元素的地址，但有两种情况例外：
> 
> 1.  sizeof(数组名)——数组名表示整个数组，计算的是整个数组大小，单位是字节
> 2.  &数组名——数组名表示整个数组，取出的是整个数组的地址

### 用法 ###

**练习一：用一维数组数组地址输出元素值（平常一般不使用这种方法）**

#include <stdio.h>
    int main()
    { 
    	int arr[5] = {  1,2,3,4,5 };
    	int(*pi)[5] = &arr;
    	int i = 0;
    	for (i = 0; i < 5; i++)
    	{ 
    		printf("%d ", *(*pi+i));
    	}
    
    	return 0;
    }

> 我们可以知道\*pi其实就是数组名，而数组名表示了数组首元素的地址，（ \*pi+i ）则表示数组每个元素的地址，再通过解引用就是每个元素的值

**练习二：写一个函数接收二维数组地址输出元素值**

void print2(int(*p)[5], int row, int col)
    { 
    	int i = 0;
    	for (i = 0; i < row; i++)
    	{ 
    		int j = 0;
    		for (j = 0; j < col; j++)
    		{ 
    			printf("%d ", *(*(p + i) + j));
    		}
    		printf("\n");
    	}
    }
    int main()
    { 
    	int arr[3][5] = {  { 1,2,3,4,5},{ 6,7,8,9,10},{ 11,12,13,14,15} };
    	print2(arr, 3, 5);
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center 1]

**练习三：判断`int(*parr[10])[5];`的parr是什么？**

> parr是一个存放数组指针的数组。该数组能存放十个数组指针。每个数组指针能够指向一个数组，该数组有五个元素，每个元素是int类型

## 4. 数组传参和指针传参 ##

在写代码时你是否经常碰到将【数组】或者【指针】传给函数，那么函数的参数该怎么设计呢？下面分别取一维数组、二维数组、一级指针、二级指针传给函，梳理出一些正确以及错误的方式

### 一维数组 ###

#include <stdio.h>
    void test(int arr[])//可以
    { }
    void test(int arr[10])//可以
    { }
    void test(int *arr)//可以，因为一维数组名就是数组首元素的地址
    { }
    void test2(int *arr[20])//可以
    { }
    void test2(int **arr)//可以
    { }
    int main()
    { 
    	int arr[10] = {  0 };//整型数组
    	int *arr2[20] = {  0 };//指针数组
    	test(arr);
    	test2(arr2);
    	return 0;
    }

> 为什么test2的第二种可以呢？首先我们要知道指针数组他的每个元素都是一个指针，而数组名是数组首元素的地址，故传过去的就是第一个指针的地址，而二级指针可以存放指针的地址

### 二维数组 ###

void test(int arr[3][5])//可以
    { }
    void test(int arr[][])//不可以，因为二维数组列的大小必须要写，行的大小可以省略
    { }
    void test(int arr[][5])//可以
    { }
    void test(int *arr)//不可以
    { }
    void test(int* arr[5])//不可以
    { }
    void test(int (*arr)[5])//可以
    { }
    void test(int **arr)//不可以
    { }
    int main()
    { 
     	int arr[3][5] = { 0};
     	test(arr);
        return 0;
    }

>  *  因为二维数组数组名表示数组第一行的地址，如果单纯用整型指针接收，那么该指针接收到的是个有五个元素数组的地址，而不是首元素的地址。如果用数组指针接收，该指针指指向的就是一个有五个整型元素的的数组，而传过来的就是一个有五个元素数组的地址，刚好存入。
>  *  二级指针的话接受的应该是一级指针的地址，而二维数组传过去的是第一行数组的地址，两者不一样

### 一级指针 ###

#include <stdio.h>
    void print(int *p, int sz)//可以
    { 
    	int i = 0;
    	for (i = 0; i < sz; i++)
    	{ 
    		printf("%d\n", *(p + i));
    	}
    }
    int main()
    { 
    	int arr[10] = {  1,2,3,4,5,6,7,8,9 };
    	int *p = arr;
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	print(p, sz);
    	return 0;
    }

### 二级指针 ###

#include <stdio.h>
    void test(int** ptr)
    { 
    	printf("num = %d\n", **ptr);
    }
    int main()
    { 
    	int n = 10;
    	int*p = &n;
    	int **pp = &p;
    	test(pp);
    	test(&p);
    	return 0;
    }

### 小结 ###

**函数形参为一级指针，可以接收哪些参数：**

> 1.  元素的地址
> 2.  一级指针

**函数形参为二级指针，可以接收哪些参数：**

> 1.  二级指针
> 2.  一级指针变量地址
> 3.  存放一级指针的数组

## 5. 函数指针 ##

### 定义 ###

> 函数指针是指向函数的指针，存放函数地址的指针

### 用法 ###

首先我们要找到函数的地址，那么函数的地址如何表示呢？

> 函数的地址其实就是`&函数名`

#include <stdio.h>
    void test()
    { 
    	printf("hehe\n");
    }
    int main()
    { 
        printf("%p\n", test);
        printf("%p\n", &test);
        return 0;
    }
    //test和&test地址其实是一样的

知道了函数的地址后怎么写出一个函数指针呢？（引用Add函数）

> 1.  首先我们写出一个指针`*p=&Add`，意思是将函数的地址放入一个指针内
> 2.  然后这个指针指向一个函数，所以 `*p()=&Add`，又因为 () 的优先级更高一点，如果只是这样写的话， p() 结合在一起就是一个函数的形式了，所以要加括号 `( *p )()=&Add`
> 3.  而这个函数的参数是两个整型，故 `( *p )( int, int )=&Add`
> 4.  最后我们知道这个函数的返回类型是整型，故最后Add函数的指针为： `int ( *p )( int, int )=&Add`
> 5.  函数的`&函数名`与`函数名`都可以代表函数的地址，故Add函数的指针也可以写成： `( *p )( int, int )=Add`

#include <stdio.h>
    int Add(int a, int b)
    { 
    	return a + b;
    }
    int main()
    { 
    	int a = 2;
    	int b = 3;
    	int(*p1)(int, int) = &Add;
    	int(*p2)(int, int) = Add;
        
    	return 0;
    }
    //两个指针意义一样

那么一个函数指针如何使用呢？

>  *  首先我们将函数指针解引用，函数指针解引用其实我们得到的就是函数，再将参数传进去就可以使用函数指针，形式为：`(*p)(a, b)`
>  *  要注意 (\*p) 两边的括号不能去掉，因为括号优先级更高，就直接调用函数了

int main()
    { 
    	int a = 2;
    	int b = 3;
    	int(*p)(int, int) = &Add;
        int ret=Add(a, b);
    	printf("%d\n", ret);
    	printf("%d\n", (*p)(a, b));
    	return 0;
    }
    //两个输出结果一样

### 注意 ###

> 1.  函数指针既然可以写成：`( *p )( int, int )=Add`，说明`p == Add`
> 2.  用函数的写法：`ret2=Add(a, b);`
> 3.  故将Add换成p，则可以写成：`ret3=p(a, b);`
> 4.  故最终我们知道函数指针有两个写法，函数指针使用时解引用那颗星其实是没意义的，甚至你可以再加N个星

int main()
    { 
    	int a = 2;
    	int b = 3;
    	int(*p)(int, int) = &Add;
        int ret1=(*p)(a,b);
        int ret2=Add(a, b);
    	int ret3=p(a,b);
    	return 0;
    }

### 练习 ###

练习一：分析下列代码：

(*(void(*)())0)()

其实该行代码就是调用0地址处的函数，那怎么分析呢？

> 1.  `void(*)()`，其实就是一个函数指针类型
> 2.  `(void(*)())0`，其实就是对0进行强制类型转换，因为函数指针存放的就是个函数地址，所以0被解释为一个函数地址
> 3.  `*(void(*)())0`，对0地址进行解引用操作，此时相当于一个函数
> 4.  `*(void(*)())0()`，再将函数参数放入，即是调用0地址处的函数

练习二：分析下列代码：

void (*signal(int , void(*)(int)))(int);

> 1.  从`signal(int , void(*)(int))`可以知道signal是一个函数名，函数的第一个参数是整型，第二个参数是一个函数指针类型，该函数指针指向一个参数为int，返回类型是void的函数
> 2.  将`signal(int , void(*)(int))`从原式挖去后，得到的是`void (*)(int)`，这是一个函数指针类型
> 3.  故signal的返回类型也是一个函数指针，该函数指针指向一个参数为int，返回类型是void的函数。故signal是一个函数的声明

以上代码其实可以换一种形式去理解

void(*)(int) signal(int,void(*)(int));

这种形式的理解就是：有一个signal的函数，其返回值为`void (*)(int)`。

但是这种形式的语法是不支持的。因为如果这个函数的返回类型是一个指针的话，那么就要将`signal(int,void(*)(int))`那部放到`(*)`里面

void(*signal(int,void(*)(int)))(int);

然而我们可以借用typedef对类型进行重定义，使得语法可以被支持

//对void(*)(int)的函数指针类型重命名为pfun_t
    typedef void(*pfun_t)(int);
    
    pfun_t signal(int,pfun_t);

### 小结 ###

1.  函数指针有两种写法，并且使用时指针前面那颗星是没有意义的
2.  函数指针可以类比于数组指针。但是函数指针与数组指针有几大不同点：

> 1.  数组arr，其数组名等于数组首元素的地址，而&数组名等于数组的地址，arr != &arr。但是函数test（），其函数名与&函数名相等，test == &test
> 2.  函数指针指向的是一个函数，故指针后要有`(函数参数)`，而数组指针后要有`[数组大小]`
> 3.  函数指针的类型是函数的返回类型，而数组指针的类型是数组的类型

## 6. 函数指针数组 ##

### 定义 ###

> 存放函数指针的数组，存放的是同类型的函数指针（返回类型，参数都要相同）

#include <stdio.h>
    int Add(int x, int y)
    { 
    	return x + y;
    }
    int Sub(int x, int y)
    { 
    	return  x - y;
    }
    int main()
    { 
    	int(*pf1)(int, int) = Add;
    	int(*pf2)(int, int) = Sub;、
        //pfArr是一个函数指针数组
    	int(*pfArr[2])(int, int) = {  Add, Sub };
    	return 0;
    }

### 用法 ###

以一个简单的计算器代码为例：

#include <stdio.h>
    int Add(int x, int y)
    { 
    	return x + y;
    }
    int Sub(int x, int y)
    { 
    	return  x - y;
    }
    int Mul(int x, int y)
    { 
    	return  x * y;
    }
    int Div(int x, int y)
    { 
    	return  x / y;
    }
    void menu()
    { 
    	printf("******************************\n");
    	printf("****** 1.Add 2.Sub ******\n");
    	printf("****** 3.Mul 4.Div ******\n");
    	printf("*********** 0.Exit ***********\n");
    	printf("******************************\n");
    }
    int main()
    { 
    	//计算器——计算整型的加、减、乘、除
    	int input = 0;
    	do
    	{ 
    		menu();
            //存储计算器的几个简单函数（这里其实相当于一个转移表）
    		int(*pfArr[5])(int, int) = {  NULL, Add, Sub, Mul, Div };
    		int x, y;
    		int ret = 0;
    		printf("请选择:>");
    		scanf("%d", &input);
    		if (input >= 1 && input <= 4)
    		{ 
    			printf("请输入两个操作数:>");
    			scanf("%d%d", &x, &y);
    			ret = (pfArr[input])(x, y);
    			printf("ret=%d\n", ret);
    		}
    		else if (input == 0)
    		{ 
    			printf("退出程序\n");
    			break;
    		}
    		else
    			printf("选择错误,重新选择\n");
    	} while (input);
    	return 0;
    }

## 7. 指向函数指针数组的指针 ##

### 定义 ###

> 存放函数指针数组的地址的指针

### 用法 ###

体验一下下面这段代码：

int(*p1)(int, int);//函数指针
    int(*p2[4])(int, int);//函数指针数组
    int(*(*p3)[4])(int, int) = &p2;//p3就是一个指向函数指针数组的指针

## 8. 回调函数 ##

### 定义 ###

>  *  回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一 个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
>  *  回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

### 用法 ###

我们可以写一个函数：

int Calc(int(*p)(int, int))
    { 
    	int x, y;
    	printf("请输入两个数:>");
    	scanf("%d%d", &x, &y);
    	return p(x, y);
    }
    int ret=Calc(Add);

> 这个Calc函数的参数其实是Add函数的地址，我们在使用Calc函数时，调用了Add函数。所以这种机制就叫做回调函数机制

接下来我们模仿qsort排序实现一个冒泡排序，以便于我们可以对非整型函数实现冒泡排序

#include <stdio.h>
    #include <stdlib.h>
    void Swap(char* p1, char* p2, int width)//将每个值的每个字节都进行交换
    { 
    	int i = 0;
    	for (i = 0; i < width; i++)
    	{ 
    		char tmp = *p1;
    		*p1 = *p2;
    		*p2 = tmp;
    		p1++;
    		p2++;
    	}
    }
    void bubble_qsort(void* base, int sz, int width, int(*cmp)(const void *p1, const void *p2))
    { 
    	int i = 0;
    	for (int i = 0; i < sz - 1; i++)//趟数
    	{ 
    		int j = 0;
    		for (j = 0; j < sz - 1 - i; j++)//每趟排序
    		{ 
    			//两个元素比较
    			//用char的原因是不知道数据类型，但我们知道每个字节宽度，故用char将指针单位变为1就可
    			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
    			{ 
    				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
    			}
    		}
    	}
    }
    int cmp_int(const void * p1, const void * p2)
    { 
    	return (*(int *)p1 - *(int *)p2);
    }
    void test()
    { 
    	int arr[] = {  1,3,5,7,9,2,4,6,8,0 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	bubble_qsort(arr, sz, sizeof(int), cmp_int);
    	int i = 0;
    	for (int i = 0; i < sz; i++)
    	{ 
    		printf("%d ", arr[i]);
    	}
    }
    int main()
    { 
    	test();
    	return 0;
    }

其中就是用了回调函数的机制，大家可以自己寻找！

### 补充（qsort函数） ###

void qsort(
        void *base,
        size_t num,
        size_t size,
        int (*compar)(const void *, const void *)
        );
    
    //void*：可以存放任意类型 
    //base：中存放的是待排序数据中第一个对象的地址
    //num：排序数据元素的个数
    //size：排序数据中每个元素的大小（字节）
    //(*compar)(const void *, const void *)：用来比较待排序数据中的2个元素的函数，决定了排序的顺序(使用者来实现)

>  *  功能：qsort()函数可以进行排序，是用了快排的方法
>  *  头文件：<stdlib.h>
>  *  注意：如果两个元素的值是相同的，那么它们的前后顺序是不确定的。也就是说qsort()是一个不稳定的排序算法

compar参数的返回值决定排序顺序

> 1.  如果compar返回值小于0，那么前一个指针所指向元素会被排在后一个指针所指向元素的前面
> 2.  如果compar返回值等于0，那么前一个指针所指向元素与后一个指针所指向元素的顺序不确定
> 3.  如果compar返回值大于0，那么前一个指针所指向元素会被排在后一个指针所指向元素的后面

看下面一段代码，体悟一下qsort函数

#include <stdio.h>
    #include <stdlib.h>
    //qosrt函数的使用者得实现一个比较函数
    int int_cmp(const void * p1, const void * p2)
    { 
    	return (*(int *)p1 - *(int *)p2);
    }
    int main()
    { 
    	int arr[] = {  1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    	int i = 0;
    	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
    	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    	{ 
    		printf("%d ", arr[i]);
    	}
    	printf("\n");
    	return 0;
    }

再来看一段代码：

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    struct Stu
    { 
    	char name[20];
    	int age;
    };
    int com_age(const void* p1, const void* p2)
    { 
    	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
    }
    void test1()//按照年龄来排序
    { 
    	struct Stu s[] = {  { "C",50},{ "Java",25},{ "Python",36} };
    	int sz = sizeof(s) / sizeof(s[0]);
    	qsort(s, sz, sizeof(s[0]), com_age);
    	for (int i = 0; i < sz; i++)
    	{ 
    		printf("%d ", s[i].age);
    	}
    }
    int com_name(const void* p1, const void* p2)
    { 
    	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
    }
    void test2()//按照名字来排序
    { 
    	struct Stu s[] = {  { "C",50},{ "Java",25},{ "Python",36} };
    	int sz = sizeof(s) / sizeof(s[0]);
    	qsort(s, sz, sizeof(s[0]), com_name);
    	for (int i = 0; i < sz; i++)
    	{ 
    		printf("%s ", s[i].name);
    	}
    }
    int main()
    { 
    	test1();//按照年龄来排序
    	printf("\n");
    	test2();//按照名字来排序
    	return 0;
    }

## 9.总结 ##

> 本章其实是在之前基础指针那章的基础上对指针更深入的挖掘，其中有的地方主要是希望大家可以理解，并不要求掌握能写的出来。但是我相信，这章的内容你搞懂了，那么指针对你来说已经是小case啦！我是吞吞吐吐鸭，希望我写的内容大家可以喜欢！！！

[Link 1]: https://blog.csdn.net/weixin_51367845/article/details/117155834?spm=1001.2014.3001.5501
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20210913/044b6a4a61c445388ad0c6649b12efdc.png
[Link 2]: https://blog.csdn.net/weixin_51367845/article/details/117155834
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20210913/2c4651f63fd54a3c938c5f2f9fb343da.png