123-学习C指针

谁践踏了优雅 2022-12-31 09:27 133阅读 0赞

内存区的每一个字节有一个编号，这就是“地址”，它相当于房间号。  
通过地址能找到所需的变量单元，我们可以说，地址指向该变量单元。  
指针就是地址

int main()
    {
        
    	int a = 10;
    	int b = 20;
    	int *p; //定义整型指针(地址)变量
    	p = &a; //”&”取地址符,&a 取 a 的地址
    	int *p1 = &a; //等同 p
    	*p = 100; //*p:对 p 解引用,即为 a=100;
    	p = &b; //p 赋值为 b 的地址
    	*p = 200; //b = 200;
    
    	return 0;
    }

第 3,4 行代码,分别定义整型变量 a,b 并赋值。a,b 分别为 4 字节,那么它们在内存中一定占用空间,假设它们的地址(指针,门牌号)内存如下:  
![在这里插入图片描述][2020122913155057.png_pic_center]  
用红色字体表示地址,用于区分一般的数字,好比你的身份证号也是一串数字,但它不是普通的数字。 第 5 行代码,定义一个指针类型的变量。  
指针变量的定义: 类型 \* 变量名;这里的\*表示变量是个指针变量。指针就是地址,所以 int *p;也是定义了一个整型地址变量。  
第 6 行代码,&a 是获取 a 的地址,”&变量”的含义是获取该变量的地址。整句代码的意思就是整型变量 a 的地址赋值给一个整型地址变量 p。赋值后如下图所示  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]  
由于 p 保存了 a 的地址,那么 p 就和 a 建立了联系,好比我有你的微信号,那么我可以通过微信联系你。那么 p 又是如何联系 a 呢?C 定义了一种访问形式,如 第 8 行代码 \* p = 100;表示从 p 间接访问到 a 并将 a 的值改为 100,这里的*号表示间接访问符或解引用的意思,注意和 int *p 的*区分。  
int \*p = &a;//定义时(前面有数据类型),\*表示这是一个指针变量  
*p = 100; //使用时*表示间接访问或解引用  
第 9 行代码,p 是一个变量,它能保存 a 的地址,它也能保存 b 的地址,执行这句代码后,示意图如下:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]  
第 10 行代码,通过解引用从 p 访问到 b 将 b 的值改为 200。

下面看这段代码

int main()
    {
        
    	int a = 10;
    	int b = 20;
    	int *p; //定义整型指针(地址)变量
    	p = &a; //”&”取地址符,&a 取 a 的地址
    	*p = 100; //*p:对 p 解引用,即为 a=100;
    	p = &b; //p 赋值为 b 的地址
    	*p = 200; //b = 200;
    	int **pp = &p; //二级指针变量 pp 赋值为 p 的地址
    	*pp = &a; //p = &a;
    	**pp = 1000; //a = 1000;
    	*pp = &b; //p = &b
    	**pp = 2000; //b = 2000;
    	return 0;
    }

第 10 行代码,p 是一个指针变量,指针变量也是变量,&p 就获取了 p 的地址。 a 是 int 类型,&a 是 int \*类型  
p 是 int \*类型,&p 就是 int \* \*类型,也就是一个整型的二级指针。 第 10 行定义了一个二级指针变量 pp,保存 p 的地址。如下图,假设 p 的地址为 4000  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]  
第 11 行,\*pp 从 pp 解引用到 p,整句代码即相当 p = &a;  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]  
第 12 行,\**pp,可以看作是*(\*pp),那么就是从 pp 解引用到了 p,p 还是指针  
继续解引用到了 a,所以整句代码相当 a = 1000;  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]  
第 13 行,\*pp 从 pp 解引用到 p,整句代码相当 p = &b;  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]  
第 14 行,\**pp 可以看作*(\*pp),即从 pp 解引用到 p,再解引用到 b,整句代码相当 b = 2000。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]  
综上所述,指针就是地址,指针变量就是地址变量,它可以保存别的变量的地址。指针变量还是变量,所以它的值也可以改变,当然它本身也是有地址,这些特性和普通变量并没有区别,唯一的区别是指针变量多一个解引用操作。

## 2、指针变量定义和初始化 ##

**指针变量定义: 类型 \* 变量名;**

//定义指针变量
    int main()
    {
        
    	char a;
    	short b;
    	int c;
    	double d;
    	char *p1 = &a; //char 指针变量
    	short *p2 = &b; //short 指针变量
    	int *p3 = &c; //int 指针变量
    	double *p4 = &d; //double 指针变量
    	p1 = &b; //错误,指针类型不匹配
    	p3 = &a; //错误,指针类型不匹配
    	return 0;
    }

&:取地址符,&a 获取 a 的地址。  
\*:在定义时表示指针变量,如 int \*p;使用时表示解引用,\*p = 100

地址是用来给内存中所有内存进行编号的,那么地址到底设计成多宽(多少字节)主要看平台能支持的地址总数有多少。比如在生活中只有 9 个地址那么设计 1 位就好 1~9,有 80 个地址那么就需要设计成 2 位,01~80,有 56789 个地址就需要设计成 5 位 00001~56789。总之地址设计成几位主要由管理的地址数量决定的

在 32 位平台(x86),指针 4 字节(32 位);在 64 位平台(x64),指针 8 字节(64位)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]

## 3、指针的使用 ##

实现 Swap 函数,将两个数交换

void Swap(int x,int y)//交换不成功
    {
        
    	int tmp = x;
    	x = y;
    	y = tmp;
    }
    
    int main()
    {
        
    	int a = 10;
    	int b = 20;
    	printf("交换前:%d,%d\n",a,b);
    	Swap(a,b);
    	printf("交换后:%d,%d\n",a,b);
    	return 0;
    }

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

void Swap(int *p1,int *p2)
    {
        
    	int *tmp = p1;
    	p1 = p2;
    	p2 = tmp;
    }
    
    int main()
    {
        
    	int a = 10;
    	int b = 20;
    	printf("交换前:%d,%d\n",a,b);
    		Swap(&a,&b);
    	printf("交换后:%d,%d\n",a,b);
    	return 0;
    }

![在这里插入图片描述][20201229133803583.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]

void Swap(int *p1,int *p2)
    {
        
    	int *tmp; //1
    	*tmp = *p1; //2
    	*p1 = *p2; //3
    	*p2 = *tmp; //4
    }
    
    int main()
    {
        
    	int a = 10;
    	int b = 20;
    	printf("交换前:%d,%d\n",a,b);
    	Swap(&a,&b);
    	printf("交换后:%d,%d\n",a,b);
    	return 0;
    }

上面代码运行到注释的 2 这句时,程序崩溃,在编译时编译器会提醒你”使用了未初始化的局部变量”,这是因为使用了野指针。  
野指针:也称为悬挂指针,是没有访问权限的地址。这个地址有可能不存在,也有可能存在但是你不能访问。比如”长安街-5 号”这是一个不存在的地址访问当然会失败,而”中南海”这个地址是存在的,但是你却不能进入(虽然你想)。  
NULL:空指针,表示当前是一个无效的指针,注意和野指针区分。  
如果你有过网络购物的经验这两个概念就非常好区分。你在网上买了一本书,但是收货地址的手机号是空的,没有写,这就是 NULL 指针,卖家很容易辨别这个错误。如果你把手机号写错了”13888889999”,这个卖家是发现不了这个错误的,只有等到快递小哥给你打电话时才发现电话号是空号或者接电话的是王先生。

## 正确写法 ##

void Swap(int *p1,int *p2)
    {
        
    	int tmp; //注意这句不是 int *tmp;
    	tmp = *p1;
    	*p1 = *p2;
    	*p2 = tmp;
    }
    
    int main()
    {
        
    	int a = 10;
    	int b = 20;
    	printf("交换前:%d,%d\n",a,b);
    	Swap(&a,&b);
    	printf("交换后:%d,%d\n",a,b);
    	return 0;
    }

![在这里插入图片描述][20201229134108867.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]

## 4、通过指针引用数组 ##

一维数组数组名 arr 表示整个数组只有如下两种情况:  
1.在定义数组的同一个函数中,sizeof(arr),表示整个数组的字节数;  
2.在定义数组的同一个函数中,&arr+1,加整个数组的字节数。  
其他情况下数组名表示数组首元素的地址。

//指针指向数组首元素
    int main()
    {
        
    	char arr[10] = {
        'a','b','c','d','e','f'};
    	short brr[10] = {
        1,2,3,4,5,6,7};
    	int crr[10] = {
        10,20,30,40,50,60};
    	float drr[10] = {
        12.5,23.5,45};
    	double err[] = {
        23.4,45.6,67.8};
    	char *p1 = arr;
    	short *p2 = brr;
    	int *p3 = crr;
    	float *p4 = drr;
    	double *p5 = err;
    
    	return 0;
    }

**指针+整数**  
那么通过指针如何访问数组中的元素呢?以字符类型指针和数组 char \*p1 = arr;为例。假设数组的起始地址为 100  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 12]  
如上图 p1+1 表示加 1 个字符单元格,p1+4 表示加 4 个字符单元格,*p1 表示的正是它所指向的内容 arr\[0\],*(p1+1)表示 arr\[1\]的内容,所以利用指针输出数组数据的程序如下

//用字符指针遍历字符数组的内容
    int main()
    {
        
    	char arr[10] = {
        'a','b','c','d','e','f'};
    	char *p1 = arr;
    	for(int i=0;i<sizeof(arr)/sizeof(arr[0]);i++) //没有按照字符串处理
    	{
        
    		printf("%c ",*(p1+i));
    	}
    	printf("\n");
    	return 0;
    }

整型指针和整型数组 int *p3 = crr; 该如何操作呢?假设数组的起始地址为 100。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 13]  
如上图 p3+2 表示加 2 个整型单元格,p3+5 表示加 5 个整型单元格,*(p3+2)表示的正是它所指向的内容 crr\[2\],所以利用指针输出数组数据的程序如下:

//利用整型指针遍历整型数组
    int main()
    {
        
    	int crr[10] = {
        10,20,30,40,50,60};
    	int *p3 = crr;
    	for(int i=0;i<sizeof(crr)/sizeof(crr[0]);i++)
    	{
        
    		printf("%d ",*(p3+i));
    	}
    	printf("\n");
    	return 0;
    }

同理,浮点类型指针和数组 double \*p5 = err;该如何操作呢?假设数组的起始地址为 100。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 14]  
如上图 p5 表示指向数组开头,p5+1 表示加 1 个浮点单元格,*p5 表示的正是它所指向的内容 err\[0\],*(p5+1)表示 err\[1\]的内容,所以利用指针输出数组数据的程序如下:

//利用浮点指针遍历浮点数组
    int main()
    {
        
    	double err[] = {
        23.4,45.6,67.8};
    	double *p5 = err;
    	for(int i=0;i<sizeof(err)/sizeof(err[0]);i++)
    	{
        
    		printf("%f ",*(p5+i));
    	}
    	printf("\n");
    	return 0;
    }

把上面指针的运算放在一起,看看有什么规律呢?  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 15]  
不管是什么类型的指针,加 1 都是加一个单元格,当然不同类型单元格的大小并不一样,指针能够自调整。char 类型指针,加 1 则加一个单元格为 1 字节;int类型指针,加 1 则加一个单元格为 4 字节;double 类型指针,加 1 则加一个单元格为 8 字节。  
指针类似时间,如果是 12 分,加 1 应该是 13 分;16 时,加 1 应该是 17 时,2020年加 1 应该是 2021 年  
综上,不同类型的指针加 1 都是加一个单元格,但是从字节上说是不同的。那如果只是计算地址时,该如何计算呢？  
结论:指针+整数,字节数需要调整,调整的权重就是 sizeof(指针去掉一个\*)。例如:  
int \*p,调整的权重为 sizeof(int); int *去掉一个*为 int。  
char \*p,调整的权重为 sizeof(char);char *去掉一个*为 char。  
double \*p,调整的权重为 sizeof(double);double *去掉一个*为 double。 char \*\*p,调整的权重为 sizeof(char *);char \*\*去掉一个*为 char \*

//指针加整数
    int main()
    {
        
    	int *p = (int *)2000;//野指针,不能解引用,借这个值进行后面的计算
    	printf("int* -> %d\n",p+3);
    	printf("char* -> %d\n",(char *)p+3);
    	printf("short* -> %d\n",(short *)p+3);
    	printf("float* -> %d\n",(float *)p+3);
    	printf("double* -> %d\n",(double *)p+3);
    	printf("long long* -> %d\n",(long long *)p+3);
    	printf("char** -> %d\n",(char **)p+3);
    	printf("double*** -> %d\n",(double ***)p+3);
    	printf("unsigned long -> %d\n",(unsigned long)p+3);
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 16]  
**指针-整数**

指针不仅可以加一个整数,当然也能减去一个整数

int main()
    {
        
    	char arr[10] = {
        'a','b','c','d','e','f'};
    	int brr[10] = {
        1,2,3,4,5,6,7,8,9,10};
    	double crr[] = {
        12.3,34.5,56.7};
    	char *p1 = &arr[5];
    	int *p2 = &brr[5];
    	double *p3 = &crr[2];
    	return 0;
    }

假设 arr,brr,crr 的地址都是从 100 开始,示意图如下:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 17]  
不管是什么类型的指针,减 1 都是减一个单元格,当然不同类型单元格的大小并不一样,指针能够自调整。char 类型指针,减 1 则减一个单元格为 1 字节;int类型指针,减 1 则减一个单元格为 4 字节;double 类型指针,减 1 则减一个单元格为 8 字节

综上,不同类型的指针减 1 都是减一个单元格,但是从字节上说是不同的  
结论:指针-整数,字节数需要调整,调整的权重就是 sizeof(指针去掉一个\*)。

//指针减数字
    int main()
    {
        
    	int *p = (int *)0x2010;//十六进制
    	printf("%x\n",p-2);
    	printf("%x\n",(char *)p-2);
    	printf("%x\n",(short *)p-2);
    	printf("%x\n",(float *)p-2);
    	printf("%x\n",(double *)p-2);
    	printf("%x\n",(long **)p-2);
    	printf("%x\n",(unsigned long)p-2);//不是指针,不需要调整
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 18]  
**指针+指针**  
指针不能加指针。比如时间,17 时可以加 1 为 18 时,17 时可以减 1 为 16 时。 而 17 时不能加 16 时。那么指针可以相减吗?

**指针-指针**  
17 时减 16 时结果是 1 小时,18 分减 16 分为 2 分,20 秒减 15 秒为 5 秒。那么指针减指针呢?

//指针减指针
    int main()
    {
        
    	char arr[10] = {
        'a','b','c'};
    	int brr[10] = {
        1,2,3};
    	double crr[] = {
        12.3,34.5,56.7};
    	char *p1 = arr;
    	char *p2 = &arr[5];
    	int *p3 = brr;
    	int *p4 = &brr[5];
    	double *p5 = crr;
    	double *p6 = &crr[2];
    	printf("%d\n",p1-p2);
    	printf("%d\n",p2-p1);
    	printf("%d\n",p3-p4);
    	printf("%d\n",p4-p3);
    	printf("%d\n",p5-p6);
    	printf("%d\n",p6-p5);
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 19]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 20]  
指针-指针结果为间隔的单元格数,正数表示前面的地址大,负数表示前面的地址小

[2020122913155057.png_pic_center]: /images/20221120/5df2e92cf04f4da59be8129bf0d59eb7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20201229131703296.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201229131824197.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201229132205286.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201229132239565.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201229132319324.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201229132354379.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20201229132431177.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20201229132741884.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/20201229132809380.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]: https://img-blog.csdnimg.cn/20201229133119690.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[20201229133803583.png_pic_center]: https://img-blog.csdnimg.cn/20201229133803583.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]: https://img-blog.csdnimg.cn/20201229133811646.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[20201229134108867.png_pic_center]: https://img-blog.csdnimg.cn/20201229134108867.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]: https://img-blog.csdnimg.cn/20201229134158783.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 12]: https://img-blog.csdnimg.cn/20201229134430657.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 13]: https://img-blog.csdnimg.cn/20201229134559825.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 14]: https://img-blog.csdnimg.cn/20201229134715662.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 15]: https://img-blog.csdnimg.cn/20201229134851921.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 16]: https://img-blog.csdnimg.cn/20201229135114655.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 17]: https://img-blog.csdnimg.cn/20201229135245422.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 18]: https://img-blog.csdnimg.cn/20201229135432478.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 19]: https://img-blog.csdnimg.cn/20201229135622541.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 20]: https://img-blog.csdnimg.cn/20201229135646748.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center