C day16 预处理器（一）

傷城~ 2023-07-06 14:38 5阅读 0赞

### 文章目录 ###

*  预处理器
 *   *  预处理之前，编译器要做三件事
     *   *  把源代码的字符映射到源字符集
         *  删除反斜杠后面是换行符的实例（把两个物理行转换为一个逻辑行）
         *  把文本划分为 预处理器记号序列 空白序列 注释序列
     *  \#define（不止可以定义符号常量！）
     *   *  宏
         *   *  空宏
             *  类对象宏 object-like macro
             *   *  示例
             *  类函数宏 function-like macro（在\#define 中使用参数）
             *   *  示例 函数宏的陷阱
             *  双引号中的宏怎么打印（字符串化 stringizing）
             *  记号粘合剂 \#\#运算符
             *  变参宏
         *  宏和函数的对比
     *  \#include
     *   *  头文件中可包含5项内容
         *  示例
         *  用头文件声明外部变量供其他文件共享

![在这里插入图片描述][20200219182144948.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]![在这里插入图片描述][2020021922123228.png]

# 预处理器 #

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

预处理指令**从\#开始，到后面的第一个换行符为止**。所以**只可以占据一行**哦

预处理指令的有效范围是**定义处到文件结尾**。如果宏通过头文件引入，则宏的作用域是\#include指令开始到文件结尾。所以本质上，**宏具有文件作用域**。

\#前面可以有空格或制表符，可以出现在源文件的任何地方

## 预处理之前，编译器要做三件事 ##

我很惊讶，预处理本来就是执行程序之前的操作了，没想到预处理器之前还有“预处理”。  
这些处理基本都是翻译，替换，和代码本身也是无关的。

### 把源代码的字符映射到源字符集 ###

写代码时可能用到各种编码，不一定只用到ASCII码，扩展字符集比如UTF-8都是多字节编码，可以使得C更加国际化，所以编译器需要把程序员使用的编码映射到C自己支持的扩展字符。

### 删除反斜杠后面是换行符的实例（把两个物理行转换为一个逻辑行） ###

非常easy，不过我很震惊这竟然是预处理之前编译器会做的事情，以前没仔细研究还真不知道这件事编译器是什么时候做的。看来编译器真的很重要，需要做好多事情啊，有的是为了方便程序员，有的又是需要遵从C标准，甚至有时候是要和操作系统来往。

physical line

logical line

举个栗子，内容太长，一行写不下，可以在反斜杠后面换行，编译器会知道你的意思，其实仍然只有一行，只是物理上占用了两行。  
![在这里插入图片描述][20200219183433953.png]

puts("Enter a line: \ (empty line to quit.)");

pycharm也允许这么做  
![在这里插入图片描述][20200220153200849.png]

### 把文本划分为 预处理器记号序列 空白序列 注释序列 ###

![在这里插入图片描述][20200219183603857.png]  
原来注释在预处理之前就被抹去了  
![在这里插入图片描述][20200219183627278.png]

**做完这三件事情，编译器就会让程序进入预处理阶段**，预处理器就开始查找每一行中**以\#开头的预处理指令**。

## \#define（不止可以定义符号常量！） ##

除了\#include之外，用的最多的预处理指令只有一个，就是\#define，用来定义符号常量（也叫明示常量 manifest constant），但是\#define很强大，还有很多其他用途。

\#define指令的结构分为三部分：  
第一部分: \#define  
第二部分： 宏  
第三部分: 替换体

替换体是**记号型字符串**，记号（token）, 记号不能有空格

### 宏 ###

对于什么是宏，我一直非常不懂，困惑了很久很久，今天终于明白了，很简单，也明白了为啥word那种文本处理软件也有宏的概念和代码了，但是不明白为啥他会被叫做macro，为什么叫这个名字呢？毕竟名字肯定和特性有点关系

宏就是\#define后面紧跟着的缩写，一般都是大写的，根据宏后面的替换体是指还是函数，宏又分为类对象宏（object-like macro）和类函数宏（function-like macro）。

宏的命名遵循C变量命名规则，中间**不可以有空格**，只可以用字母，数字，下划线，首字符不可为数字。

**宏展开** macro expansion就是**从宏变为替换体的过程**。

#### 空宏 ####

如

#define GOOD

只有宏，没有替换体就是空宏

#### 类对象宏 object-like macro ####

##### 示例 #####

#include <stdio.h>
    #define TWO 2 //数值常量
    //字符串常量
    #define OW "Consistency is the last refuge of \ the unimaginative. - Oscar Wilde "/*一致性是缺乏想象力的人最后的避难所*/
    //符号常量的表达式,宏定义中包含已经定义的宏（嵌套宏定义）
    #define FOUR TWO*TWO
    //函数表达式
    #define PX printf("x is %d.\n", x)
    //格式字符串
    #define FMT "x is %d.\n"
    
    int main()
    { 
        int x = TWO;
    
        PX;
        x = FOUR;//先替换为x=TWO*TWO；再替换为x=2*2
        printf(FMT, x);
        printf("%s\n", OW);
        printf("TWO: OW\n");//双引号中的宏不会被替换
    
        return 0;
    }

x is 2.
    x is 4.
    Consistency is the last refuge of the unimaginative. - Oscar Wilde
    TWO: OW

函数中如果要多次使用格式字符串，可以像上面那样用宏定义，把格式字符串作为替换体；当然也可以用一个const char指针指向这个字符串

const char *st = "x is %d.\n";

但是宏的作用不是可以完全由const替代的，但是C++中允许用const值作为常量表达式的一部分  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 2]

#### 类函数宏 function-like macro（在\#define 中使用参数） ####

之前说getchar(), putchar()不是函数，而是宏，我不明白，原来就是类函数宏呀

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

##### 示例 函数宏的陷阱 #####

这个程序演示了**函数调用和宏调用的区别**：函数调用在**运行时**把参数的**值**传给函数；宏调用在**编译之前**把参数的**记号**传给程序。所以x+2的平方会算错

#include <stdio.h>
    #define SQUARE(X) X*X //SQUARE是宏标识符, X是宏参数，X*X是替换列表
    #define PR(X) printf("The result is %d.\n", X)
    
    int main()
    { 
        int x = 5;
        int z;
    
        printf("x = %d\n", x);
    
        z = SQUARE(x);//宏调用
        printf("Evaluating SQUARE(x):");
        PR(z);
    
        z = SQUARE(2);
        printf("Evaluating SQUARE(2):");
        PR(z);
    
        printf("Evaluating SQUARE(x+2):");
        PR(SQUARE(x+2));//被替换为5+2*5+2
    
        printf("Evaluating 100/SQUARE(2):");
        PR(100/SQUARE(2));//被替换为100/2*2
    
        printf("x is %d.\n", x);
        printf("Evaluating SQUARE(++x):");
        PR(SQUARE(++x));//被替换为++x*++x,所以x被递增两次
        printf("After incrementing, x is %x.\n", x);
    
        return 0;
    }

会得到非常奇怪的结果

x = 5
    Evaluating SQUARE(x):The result is 25.
    Evaluating SQUARE(2):The result is 4.
    Evaluating SQUARE(x+2):The result is 17.
    Evaluating 100/SQUARE(2):The result is 100.
    x is 5.
    Evaluating SQUARE(++x):The result is 49.
    After incrementing, x is 7.

上面出现的问题的解决：

*  问题1：SQUARE(x+2)

#define SQUARE(X) (X)*(X)

*  问题2：SQUARE(100/SQUARE(2))

#define SQUARE(X) ((X)*(X))

*  问题3：SQUARE(++x)  
    不要在宏参数中使用递增递减运算符，不然很危险

#### 双引号中的宏怎么打印（字符串化 stringizing） ####

之前说了，双引号中的宏不会被替换，会被识别为普通文本

#include <stdio.h>
    #define SQUARE(X) ((X)*(X))
    #define PR(X) printf("The square of X is %d.\n", X)
    
    int main()
    { 
        int y = 5;
    
        printf("Evaluating SQUARE(y):\n");
        PR(SQUARE(y));
    
        return 0;
    }

Evaluating SQUARE(y):
    The square of X is 25.

怎么把X也替换为y或者其他表达式呢  
答案是使用\#，并利用**字符串的串联**

当然啦，这么做也还是赶不上printf的灵活程度的哈，但是比刚才好, 这就叫字符串化

#include <stdio.h>
    #define SQUARE(X) ((X)*(X))
    #define PR(X) printf("The square of "#X" is %d.\n", X)
    /*#x被替换为"x", 格式字符串变为"The square of ""SQUARE(y)"" is %d.\n", 由于双引号的字符串串联特性，这个字符串就相当于"The square of SQUARE(y) is %d.\n"*/
    int main()
    { 
        int y = 5;
    
        printf("Evaluating SQUARE(y):\n");
        PR(SQUARE(y));
    
        return 0;
    }

Evaluating SQUARE(y):
    The square of SQUARE(y) is 25.

#### 记号粘合剂 \#\#运算符 ####

\#\#就像胶水一样，把替换体中的空格分开的记号合并在一起，就这么简单。和上面刚说的\#运算符一样，只作用于替换体。

#include <stdio.h>
    #define XNAME(n) x ## n
    #define PRINT_XN(n) printf("x"#n" is %d.\n", x ##n)
    
    int main()
    { 
        int XNAME(1) = 12;//相当于int x1 = 12;
        int XNAME(2) = 15;//相当于int x2 = 15;
        int x3 = 24;
    
        PRINT_XN(1);
        PRINT_XN(2);
        PRINT_XN(3);
    
        return 0;
    }

x1 is 12.
    x2 is 15.
    x3 is 24.

#### 变参宏 ####

stdvar.h头文件提供了工具让用户定义可变参数的函数，比如printf。

C99和C11对宏也提供了这种工具，可以定义可变参数的宏。要用到预定义宏

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

#include <stdio.h>
    #include <math.h>
    #define PR(X, ```) printf("Message "#x" :", __VA_ARGS__)
    
    int main()
    { 
        double x = 48;
        double y;
    
        y = sqrt(x);
        PR(1, "x = %g\n", x);
        PR(2, "x = %.2f, y = %.4f\n", x, y);
        return 0;
    }

我无法通过编译，说省略号不能出现在宏的参数列表中，还说预定义宏\_\_VA\_ARGS\_\_也不可以出现

error: “\`” may not appear in macro parameter list

warning: **VA\_ARGS** can only appear in the expansion of a C99 variadic macro

### 宏和函数的对比 ###

既然宏可以实现和函数相似的功能，那么他们有什么区别呢  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 5]

即：**宏节省时间，浪费空间；函数节省空间，浪费时间**。

宏对时间的节省效果要在**嵌套循环**中使用才能体会出来，一个循环都还不是很明显，除非一次循环很多很多次

但是宏不管变量是什么类型的，函数却要非常严格地写清类型和匹配

一般只是很简单的函数，我们会用宏，复杂的肯定还是用函数。毕竟上面的例子也说明了，宏使用中可能出现各种没想到的错误，当然是因为我们自己对宏的把握不够深入造成的，不是宏造成的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 6]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 7]  
看来内联代码和宏很相似？只是替换生成的语句？

## \#include ##

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

### 头文件中可包含5项内容 ###

*  明示常量：比如stdio.h中的EOF,NULL,BUFSIZ(标准I/O缓冲区大小)
 *  宏函数定义：getchar()是宏，getc(stdin)是用getchar()定义的宏，getc()又用于定义更复杂的宏函数。ctype.h中的函数也是宏函数。
 *  结构模板
 *  函数原型
 *  类型定义（typedef）

下面的示例展示了四种（除了宏函数）

下面是stdio.h头文件中的一些常用的信息或者函数的定义  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 9]

所以我的编译器分配的缓冲区是512字节的大小

![在这里插入图片描述][20200219212440350.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 10]![在这里插入图片描述][20200220124010268.png]![在这里插入图片描述][20200220124229695.png]

原来FILE是用typedef给struct\_iobuf取的别名  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 11]

__mingw_stdio_redirect__
    int printf (const char *__format, ...)
    { 
      register int __retval;
      __builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
      __retval = __mingw_vprintf( __format, __local_argv );
      __builtin_va_end( __local_argv );
      return __retval;
    }

__mingw_stdio_redirect__
    int fprintf (FILE *__stream, const char *__format, ...)
    { 
      register int __retval;
      __builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
      __retval = __mingw_vfprintf( __stream, __format, __local_argv );
      __builtin_va_end( __local_argv );
      return __retval;
    }

__mingw_stdio_redirect__
    int sprintf (char *__stream, const char *__format, ...)
    { 
      register int __retval;
      __builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
      __retval = __mingw_vsprintf( __stream, __format, __local_argv );
      __builtin_va_end( __local_argv );
      return __retval;
    }

getchar()和putchar()的定义看不懂

__CRT_INLINE __cdecl __MINGW_NOTHROW  int getchar (void);
    __CRT_INLINE __cdecl __MINGW_NOTHROW  int getchar (void)
    { 
      return (--stdin->_cnt >= 0)
        ?  (int) (unsigned char) *stdin->_ptr++
        : _filbuf (stdin);
    }
    
    __CRT_INLINE __cdecl __MINGW_NOTHROW  int putchar(int);
    __CRT_INLINE __cdecl __MINGW_NOTHROW  int putchar(int __c)
    { 
      return (--stdout->_cnt >= 0)
        ?  (int) (unsigned char) (*stdout->_ptr++ = (char)__c)
        :  _flsbuf (__c, stdout);}

ctype.h中的函数的原型  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 12]  
stdio.h中的标准I/O函数的原型，可以看到大家的参数都有FILE指针，FILE是一个结构，里面包含着文件本身和文件缓冲区的信息  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 13]![在这里插入图片描述][20200220123459590.png]![在这里插入图片描述][20200220123516401.png]![在这里插入图片描述][2020021921283517.png]![在这里插入图片描述][20200219212903997.png]

### 示例 ###

主程序

#include <stdio.h>
    #include "names_st.h"
    
    int main()
    { 
        names candidate;
    
        get_names(&candidate);
        printf("Let's welcome ");
        show_names(&candidate);
        printf(" to this program!\n");
    
        return 0;
    }

函数定义文件

/*函数定义*/
    #include <stdio.h>
    #include "names_st.h"
    
    void get_names(names *pn)
    { 
        printf("Enter your first name:\n");
        s_gets(pn->first, SLEN);//SLEN定义在names_st.h中
        printf("Enter your last name:\n");
        s_gets(pn->last, SLEN);
    }
    
    void show_names(const names *pn)
    { 
        printf("%s %s", pn->first, pn->last);
    }
    
    char *s_gets(char *st, int n)
    { 
        char *ret_val;
        char *find;
    
        ret_val = fgets(st, SLEN, stdin);
        if(ret_val)
        { 
            find = strchr(st, '\n');
            if(find)
                *find = '\0';
            else
                while(getchar()!='\n')
                    ;
        }
    
        return ret_val;
    }

头文件

#include <string.h>//头文件可以包含其他的头文件
    #define SLEN 32//明示常量
    
    //结构模板
    struct names_st{ 
        char first[SLEN];
        char last[SLEN];
    };
    
    //类型定义
    typedef struct names_st names;
    
    //函数原型
    void get_names(names *);
    void show_names(const names *);
    char * s_gets(char *st, int n);

输出

Enter your first name:
    Mary
    Enter your last name:
    Galler
    Let's welcome Mary Galler to this program!

总之，如果自己的项目中文件定义很多，那么写一个自己的头文件把函数原型，宏函数，结构模板，类型定义，符号常量放进去很好，是一个好习惯。

### 用头文件声明外部变量供其他文件共享 ###

比如弄一个变量**报告错误情况**，头文件的这个功能就会非常有用

int status = 0;//定义式声明，在源代码文件，具有文件作用域，外部链接

extern int status; //和上面源代码文件关联的头文件中，引用式声明

所有包含了这个头文件的文件都会有上述引用式声明，注意一个文件同时有定义式声明和引用式声明没问题的。

[20200219182144948.png]: https://img-blog.csdnimg.cn/20200219182144948.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020021922120141.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[2020021922123228.png]: https://img-blog.csdnimg.cn/2020021922123228.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020021918230564.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200219183433953.png]: https://img-blog.csdnimg.cn/20200219183433953.png
[20200220153200849.png]: https://img-blog.csdnimg.cn/20200220153200849.png
[20200219183603857.png]: https://img-blog.csdnimg.cn/20200219183603857.png
[20200219183627278.png]: https://img-blog.csdnimg.cn/20200219183627278.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020021919310484.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2020021919422398.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200219194253358.png]: https://img-blog.csdnimg.cn/20200219194253358.png
[20200219204129519.png]: https://img-blog.csdnimg.cn/20200219204129519.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200219204204762.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200219211325877.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200219211729459.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200219211842565.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200219213015100.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200219212401861.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200219212440350.png]: https://img-blog.csdnimg.cn/20200219212440350.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200220122743178.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200220124010268.png]: https://img-blog.csdnimg.cn/20200220124010268.png
[20200220124229695.png]: https://img-blog.csdnimg.cn/20200220124229695.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200220123713278.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20200220123107339.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20200220123307435.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200220123459590.png]: https://img-blog.csdnimg.cn/20200220123459590.png
[20200220123516401.png]: https://img-blog.csdnimg.cn/20200220123516401.png
[2020021921283517.png]: https://img-blog.csdnimg.cn/2020021921283517.png
[20200219212903997.png]: https://img-blog.csdnimg.cn/20200219212903997.png