C++ day8 函数（基础知识，数组）（一）

向右看齐 2023-07-11 06:12 45阅读 0赞

写自己的函数才更有乐趣，另外，深入学习STL源码可以大大提升编程效率

### 文章目录 ###

*  使用函数必须做三件事：定义、 原型、 调用
 *   *  我们应该感谢原型做的一切（C++中，函数原型必不可少）
     *   *  函数原型是接口，帮编译器省了大力气（静态类型检查）
         *   *  如果没有函数原型，可能发生的错误
             *   *  第一种：参数数目不对
                 *  第二种：参数类型不对
         *  不使用函数原型的唯一办法：在首次使用函数之前定义它
 *  函数可分为两类：有返回值的，没返回值的（void函数）
 *   *  C++的返回值可以是任何类型，除了数组！
     *  C++函数返回值的真相（主调和被调的通信：通过一块指定内存）
 *  C++ 通常按值传递参数
 *   *  示例1 又温习了一下while重复输入，体会了cin忽略换行符的好处
 *  当数组遇上函数
 *   *  示例1 int arr\[\] 和int \*arr当且仅当在函数原型和函数头中一样
     *  示例2 验证被调函数收到的地址是否和数组名相同
     *  示例3 写的过程出了很多错
     *  示例4 传递两个指针作为处理数组的函数的参数（处理数组区间的元素）
 *  指针和const的两种结合方式（都是为了保护数据）
 *   *  让指针指向一个const常量对象（把const放在指针类型的前面）
     *   *  const指针赋给const指针 可以
         *  const指针赋给普通指针 禁止
         *  普通指针赋给普通指针 可以
         *  普通指针赋给const指针 可以
     *  把指针本身声明为const常量对象 （把const放在指针变量名的前面）
     *  指向const对象的const指针
 *  函数处理二维数组 （只把数组名和行数作为参数）
 *   *  const不能用于指向指针的指针

# 使用函数必须做三件事：定义、 原型、 调用 #

**库函数已经定义好了，编译过了；原型又在头文件中**，所以我们用的时候只需要包含头文件并调用就行了

但是自己写函数的话，这三件事一个都不能少

## 我们应该感谢原型做的一切（C++中，函数原型必不可少） ##

函数原型是语句，要加分号。

写原型最好的方式：复制函数头，加分号。

函数原型的变量名只是占位符，有没有都行，和定义中的变量名不一样也行，因为它根本不是什么关键信息，编译器又不看他，因此它爱咋地就咋地。

额，其实提供一下变量名虽然对编译器无关紧要，但是可以让编程者一下知道这个参数的意义，吧变量名取为有意义的标识符，比如weight, height ，一看就知道这个形参的意义。

### 函数原型是接口，帮编译器省了大力气（静态类型检查） ###

它把函数的返回值类型，参数数量和类型这些关键信息直接告诉编译器，帮编译器省了大力气。

因为，如果没有函数原型来告知这些信息，编译器只能自己在函数定义里面找，它就要暂停编译，跑去函数定义的代码那边看一通，如果遇到一个函数调用就去人家的定义那里看看，这很浪费时间，耽搁编译效率，更严重的是，如果函数定义在另一个文件，也许编译器是没有访问权的···那咋办，只能编译失败

总结而言，原型在这几方面帮助到编译器：

*  正确处理返回值
 *  检查参数数目是否正确
 *  检查参数类型是否正确

这些由函数原型辅助进行的检查都在编译阶段进行，所以被称为静态类型检查，static type checking, 可以通过下面这一节看到，**静态类型检查可以有效避免很多在运行阶段难以捕捉的错误。**

#### 如果没有函数原型，可能发生的错误 ####

##### 第一种：参数数目不对 #####

假设cube函数的原型

double cube(double);

但是C程序

#include <stdio.h>
    int main()
    { 
        double z = cube();//调用时参数数目不对
        printf("z = %.2f", z);
        return 0;
    }
    
    double cube(double x)
    { 
        return x * x * x;
    }

假设不用原型，编译器在编译这一行遇到这个调用时，直接允许这行通过编译。然后编译器就去和主调函数约好的存放参数的位置去取值了，于是取了不知道多少，算个立方返回给主调函数了。

但是我的编译器还是在这方面下了功夫的，没给通过编译

##### 第二种：参数类型不对 #####

C程序

#include <stdio.h>
    int main()
    { 
        int z = cube(2.1);
        printf("z = %d\n", z);
        return 0;
    }
    
    int cube(int x)
    { 
        return x * x * x;
    }

编译器警告没有函数原型，但还是通过了编译，却得到了错的结果，调试发现，double类型的2.1并没有像我希望的那样被自动转换为int类型的整数2（因为函数定义中参数是int,所以编译器只会在主调和被调的指定通信内存拿4个字节的值，当然拿不到2.1！！！），然后计算得到8（其实就算那样也还是错了）

z = 652835029

但是如果把int给double参数，编译器又不让通过编译了·····

还区别对待···

真是浑水趟不得，所以不管C还是C++，大家都还是乖乖的使用原型吧

#include <stdio.h>
    int main()
    { 
        double z = cube(2);
        printf("z = %.2f\n", z);
        return 0;
    }
    
    double cube(double x)
    { 
        return x * x * x;
    }

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

### 不使用函数原型的唯一办法：在首次使用函数之前定义它 ###

但这也不是釜底抽薪的好办法，因为虽然C和C++认为所有函数人人平等，但是C++的**编程风格是把main()函数放在最前面**，好从main()中看清程序的结构。

# 函数可分为两类：有返回值的，没返回值的（void函数） #

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

有返回值的会自动转换返回值的类型为定义函数的返回值类型  
![在这里插入图片描述][20200304154424263.png]

## C++的返回值可以是任何类型，除了数组！ ##

数组果然妥妥的二等公民

但是又很有意思的是，C++没有做的太绝，给数组关上了门，又开了一个窗，即**可以允许数组是结构或者对象的组成部分，然后返回结构或者对象。**

## C++函数返回值的真相（主调和被调的通信：通过一块指定内存） ##

即到底怎么实现的

是被调函数和主调函数通过一段约定好的内存实现的，被调函数在指定的内存取参数，然后把返回值放回指定的内存。

**主调函数通过函数原型知道返回值类型。  
被调函数具体返回什么类型又是由函数定义（中的函数头）来决定的。**

所以定义和原型的返回值，参数类型啥的都得完全一样，不然编译器报错，我就说呢，至于吗，不是可以直接看定义吗，为啥必须得要原型，原来是为了保证主调和被调的通信完全正确。  
![在这里插入图片描述][20200304155258705.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]

# C++ 通常按值传递参数 #

这个通常一词，说明还有别的方式，那就是按引用传递，和JAVA 一样，后面再说，先把按值传递捋清楚

其实这一点和C一样的，就是形参实参那档子事儿，

只要记住：**实参是值，是不可修改的右值，即常量；**，C++标准用argument表示实参。

而形参是函数中定义的，由函数私有的变量，即**可修改的左值**, C++标准用parameter表示形参。

实参来自于主调函数，被调函数会把实参赋给自己定义的形参，以创建主调函数的数据的副本，即按值传递参数里，主调和被调函数互不影响对方的数据，被调只是很礼貌的复制了主调送来的值，然后对自己的复制版本进行计算，计算妥帖了再传给主调函数，当然啦，被调传回去的也是值，然后主调把这个值赋给自己的变量。

比如

double z = cube(side);//函数调用

side并不是实参哦！side是变量，他的值才是实参

double cube(double x)// 函数头

x是形参，cube函数把实参，即主调函数变量side的值赋给x

## 示例1 又温习了一下while重复输入，体会了cin忽略换行符的好处 ##

我做了次数输入的类型判断，以免错误输入数字以外的字符导致死循环

#include <iostream>
    #include <cstdlib>
    void n_chars(int times, char ch);
    
    int main()
    { 
        using namespace std;
    
        char ch;
        cout << "Enter a character(q to quit): ";
        cin >> ch;//不用cin.get()是有考虑的
        int times;
        while (ch != 'q' && ch != 'Q')
        { 
            cout << "Enter a positive integer: ";
            //cin会忽略换行符等空白符，而cin.get()不会
            //所以如果使用cin.get(),就会把上次遗留的换行符读取到
            if (!(cin >> times))
            { 
                cout << "Input failure.\nProgram terminating...\n";
                exit(EXIT_FAILURE);
            }
            n_chars(times, ch);
            cout << "Enter a character(q to quit): ";
            cin >> ch;
        }
        cout << "Bye!\n";
        return 0;
    }
    
    void n_chars(int times, char ch)
    { 
        while(times--)
            std::cout << ch;
        std::cout << std::endl;
    }

Enter a character(q to quit): a
    Enter a positive integer: 3
    aaa
    Enter a character(q to quit): d
    Enter a positive integer:
    2
    dd
    Enter a character(q to quit): f
    Enter a positive integer: a
    Input failure.
    Program terminating...

# 当数组遇上函数 #

数组和结构这类复合类型，用函数处理很方便。比如计算数组元素的和，要是不写个函数，每次都要写一个循环，很麻烦。

## 示例1 int arr\[\] 和int \*arr当且仅当在函数原型和函数头中一样 ##

示例非常简单，要说的主要是数组做参数时形参的写法，这里面有些东西还是要弄清楚的

你想，声明数组时只提供了类型，数组名和数组长度，这其中明显只有数组名没别的事情做，可以用来标记数组的内存地址呀，所以数组名是数组地址也是情理之中，很好理解。

复习一下：  
把&作用于数组名，得到整个数组的地址。  
把&作用于数组第一个元素，只能得到第一个元素的地址。  
虽然这两个地址一样，但是你把两个指针加1，移动的长度却不一样，第一个移动的是整个数组的长度，第二个移动的是第一个元素的长度。

#include <iostream>
    int sum_arr(const int arr[], int n);
    const int arSize = 5;
    
    int main()
    { 
        using namespace std;
        int cookies[arSize] = { 1, 2, 4, 8, 16};
        cout << "cookies eaten: " << sum_arr(cookies, arSize) << endl;
        return 0;
    }
    
    int sum_arr(const int arr[], int n)
    { 
        //arr是个指针！！！不要因为它后面的方括号就以为他是数组，但是可以把它看做数组
        int i, total = 0;
        for(i = 0; i < n; ++i)
            total += arr[i];
        return total;
    }

cookies eaten: 31

其中int sum\_arr(const int arr\[\], int n)函数头和函数原型也可以写为指针形式：int sum\_arr(const int \*arr, int n)，这更加明确说明传入的是指针，**这两种方式在函数头和函数原型中是一毛一样的，其实也只是在函数头和函数原型中一毛一样**，但是**建议使用数组做形参就用第一种，因为这样明确表示我处理的是数组**。 而且前者本来也会被编译器解释为后者的。

另外，我这里在数组名形参前面用了const限定词，这表明arr指向const int类型，即是一个常量，注意这并不要求arr真的指向一个常量，只是编译器到这个函数里来看到const就会把arr指向的东西认为是只读，于是任何试图修改数组元素的就会被编译器检查到，编译出错。比如

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]  
每一个数组元素都不能改，不只是第一个哈

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

可以看到，把数组作为参数，并没有把整个数组都传给被调函数，毕竟那是一个很笨的办法，数组越大则越笨，因为复制数组的时间和内存开销都好大好大···

直接传地址和长度就好了嘛，当然元素类型也要传，就解决了。但是，这也使得在使用数组为参数的时候，被调函数可以直接处理原数组了，而不是处理他的副本。那这样好像和前面说的按值传递有点矛盾。

但是这**仍然是按值传递**的函数通信方式，因为数组名是个地址，传的就是这个地址，地址就是一个常量值啊，这个值被赋给了函数的形参arr。

所以**按值传递强调的是传递的确实是一个常量值，而不是强调不能使用主调函数的原变量。**

## 示例2 验证被调函数收到的地址是否和数组名相同 ##

#include <iostream>
    int sum_arr(const int arr[], int n);
    const int arSize = 5;
    
    int main()
    { 
        int cookies[arSize] = { 1, 2, 4, 8, 16};
        std::cout << "In main(), cookies: " << cookies << std::endl;
        std::cout << "In main(), sizeof cookies: " << sizeof cookies << std::endl;
        std::cout << "cookies eaten: " << sum_arr(cookies, arSize) << std::endl;
        //可以提供假的数组长度，以只算前一部分的值的和
        std::cout << "First 2 eaters ate: " << sum_arr(cookies, 2) << std::endl;
        //还可以提供假的指针，以求数组后半部分的值的和
        std::cout << "Last 3 eaters ate: " << sum_arr(cookies + 2, 3) << std::endl;
        return 0;
    }
    
    int sum_arr(const int arr[], int n)
    { 
        int i, total = 0;
        std::cout << "In sum_arr(), arr: " << arr << std::endl;
        std::cout << "In sum_arr(), size of arr: " << sizeof arr << std::endl;
        for(i = 0; i < n; ++i)
            total += arr[i];
        return total;
    }

可以看到，被调函数中传入的地址就是数组真正的地址，所以是按值传递，传了数组名的常量地址值

In main(), cookies: 0x6dfedc
    In main(), sizeof cookies: 20
    In sum_arr(), arr: 0x6dfedc
    In sum_arr(), size of arr: 4
    cookies eaten: 31
    In sum_arr(), arr: 0x6dfedc
    In sum_arr(), size of arr: 4
    First 2 eaters ate: 3
    In sum_arr(), arr: 0x6dfee4
    In sum_arr(), size of arr: 4
    Last 3 eaters ate: 28

## 示例3 写的过程出了很多错 ##

#include <iostream>
    int fill_array(double arr[], int limit);
    void revalue(double factor, double arr[], int limit);
    void show_array(const double arr[], int limit);
    const int arSize = 20;
    
    int main()
    { 
        double properties[arSize] = { };
        double factor;
        int size;
    
        size = fill_array(properties, arSize);
        show_array(properties, size);
    
        std::cout << "Enter the revalue factor: ";
       while (!(std::cin >> factor))
        { 
            std::cin.clear();
            while (std::cin.get() != '\n')
                ;
            std::cout << "Bad input. Enter again: ";
        }
        revalue(factor, properties, size);
        show_array(properties, size);
        return 0;
    }
    
    int fill_array(double arr[], int limit)
    { 
        std::cout << "Fill the array:\n";
    
        int i;
        double temp;//作为输入到数组之前的正确性检查缓冲
    
        for (i = 0; i < limit; ++i)
        { 
            std::cout << "Enter value #" << (i + 1) << ": ";
            if (!(std::cin >> temp))//这里不要重复输入，用if就行
            { 
                std::cout << "Bad input. Exiting the filling function...\n";
                //下面两句非常关键！把输入缓冲队列读掉！否则如果输入数字外的字符会死循环
                std::cin.clear();//清楚错误标记
                while (std::cin.get() != '\n')//别写成temp!='\n'不然又是死循环
                    ;
                break;//不直接退出整个程序，而是退出填充数组这个函数就行
            }
            //上面的while是读取的进不进的问题，如果返回false就根本读取不到
            //而判定temp的正负的前提是已经读取到了，所以分开写比较清晰
            if (temp < 0)
            { 
                std::cout << "Negative input! Exiting the filling function...\n";
                break;
            }
            arr[i] = temp;//检查无误后才输入给数组
        }
        return i;
    }
    
    void revalue(double factor, double arr[], int limit)
    { 
        int i;
        for (i = 0; i < limit; ++i)
        { 
            arr[i] *= factor;
        }
    }
    
    void show_array(const double arr[], int limit)
    { 
        int i;
        std::cout << "Elements:\n";
        for (i = 0; i < limit; ++i)
            std::cout << arr[i] << ' ';
        std::cout << std::endl;//显示元素的函数我老是忘记加换行符，跑一遍程序看到结果才知道加
    }

输入负数导致错误

Fill the array:
    Enter value #1: 1.2
    Enter value #2: 4.2
    Enter value #3: 3.5
    Enter value #4: 4.8
    Enter value #5: -4
    Negative input! Exiting the filling function...
    Elements:
    1.2 4.2 3.5 4.8
    Enter the revalue factor: 2
    Elements:
    2.4 8.4 7 9.6

输入非数字字符导致读取错误

Fill the array:
    Enter value #1: 1.2
    Enter value #2: 2.1
    Enter value #3: 3.5
    Enter value #4: s
    Bad input. Exiting the filling function...
    Elements:
    1.2 2.1 3.5
    Enter the revalue factor: 2
    Elements:
    2.4 4.2 7

输入factor出错（和第二个一样的错误）

Fill the array:
    Enter value #1: 1.2
    Enter value #2: f
    Bad input. Exiting the filling function...
    Elements:
    1.2
    Enter the revalue factor: a
    Bad input. Enter again: .
    Bad input. Enter again: 3
    Elements:
    3.6

我写程序过程中出的错误有：

*  试图读掉错误的输入缓冲时，没有清空cin的错误标记，这样cin是不会正常工作的，使得程序死循环
 *  读掉错误缓冲输入时，使用了temp·····低级错误
 *  判定输入是否正确时，把if写成了while，结果break只能跳出while，但我是想跳出for，说明我没有足够的掌握清楚while

## 示例4 传递两个指针作为处理数组的函数的参数（处理数组区间的元素） ##

前面的三个示例，都是用了传统的C和C++中函数处理数组的方法，即传递两个参数，一个是数组名，即指向数组的指针，第二个是数组长度，但是还有另一种办法更加灵活：传递两个指针参数，一个指向数组第一个元素，一个指向数组的最后一个元素，这样数组的位置和长度信息也传递了，当然元素类型也传递了。

这种传递两个指针的方式**和STL（C++的标准模板库）的算法实现一样**哦

这个示例还是示例1的曲奇饼干，但是可以看到灵活很多，可以算数组的中间区间的元素之和

这里用到了“超尾”的概念，即指向数组最后一个元素的后面一个元素的指针，传递的第二个指针就是超尾。

#include <iostream>
    int sum_arr(const int *begin, const int *end);
    const int arSize = 5;
    
    int main()
    { 
        using namespace std;
        int cookies[arSize] = { 1, 2, 4, 8, 16};
        cout << "cookies eaten: " << sum_arr(cookies, cookies + arSize) << endl;//注意cookies + arSize是超尾
        //不是指向最后一个元素
        //而是最后一个元素的后面那个元素
        cout << "eaters 1-3 eaten: " << sum_arr(cookies, cookies + 3) << endl;
        cout << "eaters 2-5 eaten: " << sum_arr(cookies + 1, cookies + arSize) << endl;
        cout << "eaters 2-4 eaten: " << sum_arr(cookies + 1, cookies + 4) << endl;
        return 0;
    }
    
    int sum_arr(const int *begin, const int *end)
    { 
    	//end-begin就是数组元素数目，即数组长度
    	//所以传指针时，必须是小指针在前，顺序不可乱！
        const int *pt;//pt必须是const指针，不能把const指针赋给非const指针，否则岂不是还是改了
        int total = 0;
        for(pt = begin; pt != end; ++pt)
            total += *pt;
        return total;
    }

cookies eaten: 31
    eaters 1-3 eaten: 7
    eaters 2-5 eaten: 30
    eaters 2-4 eaten: 14

# 指针和const的两种结合方式（都是为了保护数据） #

## 让指针指向一个const常量对象（把const放在指针类型的前面） ##

前面用的都是这种。这时候指针不是const的，所以指针的值可以改，可以加减递增啥的，即指针可以指向别人。

但是不管他指向谁，它指向的那个数据就会被编译器**看作**是只读的(实际它本身可以不是常量)，保护数据不被函数更改。

一种保护措施我们在上面这个实例中看到了，即不可以把指向const对象的指针赋给普通指针，因为这样通过普通指针就可以修改了，那岂不是没保护成功。

int age = 23;
    const int *age = &23;

总之，const数据必须和const指针搭配，否则报错

下面说const指针不是说指针本身是const的，而是他指向数据是const的，即这四个小节说const指针实际是指向const的指针的简称

### const指针赋给const指针 可以 ###

const float a = 1.2;
    const float * pa = &a;

### const指针赋给普通指针 禁止 ###

前面说了示例和原因了

尤其是在函数调用中

### 普通指针赋给普通指针 可以 ###

当然可以了·····

### 普通指针赋给const指针 可以 ###

float a = 1.2;
    const float * pa = &a;

这样子可以通过&a修改a的值，但是不能通过pa修改的值。

上面4种情况在C中也总结过，没什么深奥复杂的，使用的时候，不要混用，即乖乖用第一种和第三种就好啦。

因为第二种和第四种，const 和非const混用，只是在第一级间接关系中安全，如果有两层间接关系，那就不太安全了，即指向指针的指针

晕了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 3]  
最后，尽可能把数组等不想被更改的数据声明为const，在处理数组的函数形参中使用const，下图第二点说的深入人心  
![在这里插入图片描述][20200305142607827.png]

## 把指针本身声明为const常量对象 （把const放在指针变量名的前面） ##

第一种方式如果修改了指针的值，指针指向的数据还是被当做常量，感觉有点死板

第二种方式不限定数据本身，而限定指针，即指针的值不能改了，这个指针就只能指向这个数据了，是指针被当做常量了  
，可以用指针修改它指向数据的值  
数据本身递增递减等运算还是可以

int age = 23;
    const int * ps = &age;//ps不是const，可以让ps指向别人；*ps是const，不可以通过ps修改age
    int * const pt = &age;//pt是const，即pt只可以指向age; *pt不是const,即可以通过pt修改age的值，也可以别的方式修改age的值

## 指向const对象的const指针 ##

const double money = 10000.0;
    const double * const pt = &money;//pt只能指向money，且不能用pt修改money的值，即pt和*pt都是const

# 函数处理二维数组 （只把数组名和行数作为参数） #

用函数处理二维数组时，形参的形式更加复杂和难以理解一些

int ar[3][4] = { };
    int total = sum_ar(ar, 3);//函数调用，可见只把数组名和行数作为参数传递

这是因为列数的信息在第一个参数中

const int COLS = 4;
    int sum_ar(int (*pt)[COLS], int rows);//函数原型，列数必须以常量形式给出

这里和C一样，由于有圆括号，所以pt先和\*结合，成为指针，然后碰到方括号，说明指针指向一个4维数组。

如果没有圆括号，那么由于方括号优先级高于\*，pt会先和方括号结合，成为数组，然后和解引用运算符结合，成为指针数组，即每个元素都是指针。

但是更加明了简单，有可读性的原型形式是

const int COLS = 4;
    int sum_ar(int arr[][COLS], int rows);//这样明确表明arr是指向二维数组第一个元素数组的指针
    //可以直接把arr当做数组名来用

和之前一维数组一样，上面两种原型定义形式，即 i n t ( ∗ p t ) \[ C O L S \] int (\*pt)\[COLS\] int(∗pt)\[COLS\]和 i n t a r r \[ \] \[ C O L S \] int arr\[\]\[COLS\] intarr\[\]\[COLS\]当且仅当在函数头和函数原型中等价。

但是这两种写法（指针表示法和数组表示法）在程序中也是等价的，因为数组表示法最后会被编译器解释为指针表示法，所以这也可以看出数组法的优点是对程序员友好，非常好些好看明白，但是缺点是编译器多费点功夫；指针表示法就反过来了呗：

ar[3] = *(ar + 3);
    ar[3][4] = *(*(ar + 3) + 4);//ar是指向指针的指针

## const不能用于指向指针的指针 ##

由于ar是指向指针的指针，所以没法再上面的原型中使用const，因为const只可以用于指向基本类型的指针，不能用于指向指针的指针。

[20200304165255856.png]: https://img-blog.csdnimg.cn/20200304165255856.png
[20200304154305485.png]: https://img-blog.csdnimg.cn/20200304154305485.png
[20200304154424263.png]: https://img-blog.csdnimg.cn/20200304154424263.png
[20200304155258705.png]: https://img-blog.csdnimg.cn/20200304155258705.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200304155510886.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 1]: https://img-blog.csdnimg.cn/20200305123842894.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 2]: https://img-blog.csdnimg.cn/20200305123910615.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/20200305142436363.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200305142607827.png]: https://img-blog.csdnimg.cn/20200305142607827.png