C++ day7 if else, switch,条件运算符，逻辑运算符

淩亂°似流年 2023-07-10 15:34 12阅读 0赞

本文回顾程序的三种决策手段：if else结构，switch语句，条件运算符

还会涉及把多个测试表达式（一般是关系表达式）合并为一个测试表达式

### 文章目录 ###

*  if else
 *   *  示例1 回显输入（cout << ++ch 和 cout << ch + 1的区别！）
     *  示例2 猜数字
 *  逻辑运算符（优先级低于关系运算符）
 *   *  ||，&&是顺序点（冒号，逗号运算符也是顺序点 sequence point）
     *   *  示例 菜单选择
         *  示例2
         *  示例3 用&&设置取值范围
     *  逻辑非!（优先级高于所有算术运算符和关系运算符！！！）
     *   *  &&优先级高于||
         *  保留字不一定是关键字
         *  示例1 判断输入的数是否是int类型
 *  cctype 处理字符的函数库
 *   *  分类和统计字符数目
 *  条件运算符 （C和C++的唯一三目运算符）
 *   *  示例1 cin >> a >> b;
 *  switch语句（可以从大型列表中选择，但不可以处理取值范围）
 *   *  示例1 char int做标签
     *   *  输入缓冲很会制造麻烦
     *  把标签改为字母更好
     *  示例2 enum枚举量做标签
 *  break continue
 *   *  示例 回显字符
 *  C++也认为直接不要用goto语句
 *  示例 输入类型错误 和 EOF导致cin返回false，clear()重置错误标记

# if else #

if，while,for循环的测试表达式等，需要bool类型值的地方，程序都会自动转换为bool类型，所以if(x)和if(x ！= 0)一样的,所以**测试表达式也可以不是关系表达式，可以是一个值**

for,while,do while，if else全部都只被看作是一条语句  
![在这里插入图片描述][20200303144046994.png]  
![在这里插入图片描述][20200303144026440.png]

## 示例1 回显输入（cout << ++ch 和 cout << ch + 1的区别！） ##

#include <iostream>
    int main()
    { 
        char ch;
    
        std::cout << "Type, and I shall repeat.\n";
        while((ch = std::cin.get()) != '.')
        { 
            if (ch == '\n')
                std::cout << ch;//如果是换行符，就原样打印
            else
                std::cout << ++ch;//打印每个字符的后一个字符
        }
        return 0;
    }

Type, and I shall repeat.
    I spend too much money
    J!tqfoe!upp!nvdi!npofz
    I have to earn more.
    J!ibwf!up!fbso!npsf

如果while循环里只有std::cout << ++ch;就会像下面这样，换行符被打印为它后面的一个字符，而不会换行

Type, and I shall repeat.
    I bought a pot
    J!cpvhiu!b!qpu

如果把++ch改为ch + 1,我没猜到竟会输出ASCII码的数字！！！

cout 认为++ch还是char类型，但是ch + 1，和int类型相加，ch被整型提升为int，最终结果也是int

Type, and I shall repeat.
    I will do it well
    7433120106109109331011123310611733120102109109
    oh my god.
    1121053311012233104112101

## 示例2 猜数字 ##

#include <iostream>
    
    int main()
    { 
        const int FAV = 34;
        int n = 0;
    
        std::cout << "Enter a number in the range 1-100\n";
        do
        { 
            std::cin >> n;
            if(n > FAV)
                std::cout << "Too high------Guess again!\n";
            else if(n < FAV)
                std::cout << "Too low------Guess again!\n";
            else
                std::cout << n << " is right!\n";
        }while(n != FAV);
        return 0;
    }

Enter a number in the range 1-100
    56
    Too high------Guess again!
    30
    Too low------Guess again!
    45
    Too high------Guess again!
    35
    Too high------Guess again!
    32
    Too low------Guess again!
    33
    Too low------Guess again!
    34
    34 is right!

# 逻辑运算符（优先级低于关系运算符） #

就三个，逻辑与&&，逻辑或||，逻辑非！，和英语很像

## ||，&&是顺序点（冒号，逗号运算符也是顺序点 sequence point） ##

即||，&&**左边的表达式先修改，先判定左侧，并且在判定右侧之前产生所有的副作用**，比如

int i = 7, j = 8;
    //||是顺序点，先计算左边，i为7和8比较，左边表达式值为false，再递增i,i=8
    // 左边表达式的值如果是true，就不计算右边了；这里要计算，右边是true。所以整个逻辑表达式的值是true
    i++ > 8 || i == j;//||优先级低于关系运算符，所以不用加括号

### 示例 菜单选择 ###

#include <iostream>
    
    int main()
    { 
        std::cout << "This program will reformat your hard disk and destroy all your data"
                    ".\nDo you wish to continue?<y/n>\n";
        char ans;
        std::cin.get(ans);//只读取第一个字符
        if (ans == 'y' || ans == 'Y')
            std::cout << "You were warned!\a\a\n";
        else if(ans == 'n' || ans == 'N')
            std::cout << "A wise choice...bye!\n";
        else
            std::cout << "That wasn't a y or n!\nApparently you can't follow"
                         " instructions, so I will trash your disk anyway!\a\a\a\n";
        return 0;
    }

### 示例2 ###

脑袋晕乎乎了，昨晚没睡好，这个示例其实没什么新东西，我多敲一敲总是好点

#include <iostream>
    const int Arsize = 6;
    int main()
    { 
        using namespace std;
        float naaq[Arsize];
        cout << "Enter the NAAQs (New Age Awareness Quotients)"//新时代意识
             << " of\nyour neighbors. Program terminates "
             << "when you make\n"
             << Arsize << " entries "
             << "or enter a negative value.\n";
    
        int i = 0;
        float temp;
        cout << "First value: ";
        cin >> temp;
        while (i < Arsize && temp >= 0)
        { 
            naaq[i] = temp;
            ++i;
            if (i < Arsize)//如果递增后还小于数组长度才继续输入
            { 
                cout << "Next value: ";
                cin >> temp;
            }
        }
        if (i == 0)
        { 
            cout << "No data--bye!\n";
        }
        else
        { 
            cout << "Enter your naaq: ";
            float you;
            cin >> you;
            int count = 0;
            for (int j = 0; j < i; j++)
            { 
                if (naaq[j] > you)
                    ++count;
    
            }
            cout << count << " of your neighbors have greater awareness of"
                 " the new age than you do.\n";
        }
        return 0;
    }

Enter the NAAQs (New Age Awareness Quotients) of
    your neighbors. Program terminates when you make
    6 entries or enter a negative value.
    First value: 8.2
    Next value: 4.5
    Next value: 3.5
    Next value: 9
    Next value: -2
    Enter your naaq: 1
    4 of your neighbors have greater awareness of the new age than you do.

### 示例3 用&&设置取值范围 ###

#include <iostream>
    int main()
    { 
        using namespace std;
        const char *job[4] =
        { 
          "10,000-meter race.\n",
          "mud tug-of-war.\n",
          "masters canoe jousting.\n",
          "pie-throwing festival.\n"
        };
    
        cout << "Enter your age in years: ";
        int age;
        cin >> age;
        int index;
        if (age > 18 && age < 35)
            index = 0;
        else if (age > 35 && age < 45)
            index = 1;
        else if (age > 45 && age < 55)
            index = 2;
        else
            index = 3;
        cout << "You qualify for the " << job[index];
        return 0;
    }

Enter your age in years: 23
    You qualify for the 10,000-meter race.

注意如果写为数学形式

if (17 < age < 34)//语法有效，但是这个表达式的值会一直为true, 因为<的结合性是从左到右，
    //所以17 < age先被判定，不管值是true 还是false,都比34小，所以一定是true，这个if就一定会进去，就没有if分支决策的意义了

## 逻辑非!（优先级高于所有算术运算符和关系运算符！！！） ##

if (!(x > 5)) //等同于if (x <=5), 但是后者更清晰

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

### &&优先级高于|| ###

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

### 保留字不一定是关键字 ###

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

### 示例1 判断输入的数是否是int类型 ###

把整数输入给double变量，再送入is\_int()判断是否在int范围

#include <iostream>
    #include <cstdbool>
    #include <climits>
    bool is_int(double);
    
    int main()
    { 
        using namespace std;
        cout << "Enter an integer: ";
        double n;
        cin >> n;
        while (!is_int(n))
        { 
            cout << "Out of range! Please try again!\n";
            cin >> n;
        }
        int val;
        val = int (n);
        cout << "You entered the integer " << val << endl;
        return 0;
    }
    
    bool is_int(double n)
    { 
        if (n <= INT_MAX && n >= INT_MIN)
            return true;
        else
            return false;
    }

Enter an integer: 2147483648
    Out of range! Please try again!
    2147483647
    You entered the integer 2147483647

但是这个程序的缺陷是，没有检查用户输入是否是整数，而是信任用户，可是用户输入浮点数，is\_int()也会返回true

Enter an integer: 3.4
    You entered the integer 3

所以修改is\_int()函数的判定表达式

if (n <= INT_MAX && n >= INT_MIN && long (n) == n)

Enter an integer: 3.4
    Out of range! Please try again!
    5
    You entered the integer 5

# cctype 处理字符的函数库 #

cctype是从C里面的ctype.h发展来的。 char type

里面有很多库函数，可以判断字符是不是字母，大写，小写，标点符号等等，如果使用库函数，有时候比写关系和逻辑表达式简单一些，比如判断字符是不是字母,并且还**更通用**，毕竟ascii码是连续的，那如果某个编码的所有字母不是连续的呢，就不能用逻辑表达式了，所以isalpha()这类库函数的用武之地很大的

//cctype
    if (isalpha(ch))//如果ch是字母，则isalpha(ch)返回true
    
    //逻辑表达式
    if ((ch >= 'a' && ch <= 'z') || (ch <= 'Z' && ch >= 'A'))

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

## 分类和统计字符数目 ##

#include <iostream>
    #include <cctype>
    int main()
    { 
        using namespace std;
        int whitespaces = 0;
        int digits = 0;
        int chars = 0;
        int punct = 0;
        int others = 0;
    
        cout << "Enter a text for analysis: (enter @ to quit)\n";
        char ch;
        cin.get(ch);
        while (ch != '@')
        { 
            if (isspace(ch))
                ++whitespaces;
            else if (isalpha(ch))
                ++chars;
            else if (isdigit(ch))
                ++digits;
            else if (ispunct(ch))
                ++punct;
            else
                ++others;
            cin.get(ch);
        }
        cout << "whitespaces: " << whitespaces << endl;
        cout << "digits: " << digits << endl;
        cout << "characters: " << chars << endl;
        cout << "punctuations: " << punct << endl;
        cout << "others: " << others << endl;
        return 0;
    }

Enter a text for analysis: (enter @ to quit)
    I am a superman, and I am the No.1@
    whitespaces: 8
    digits: 1
    characters: 23
    punctuations: 2
    others: 0

# 条件运算符 （C和C++的唯一三目运算符） #

## 示例1 cin >> a >> b; ##

#include <iostream>
    int main()
    { 
        using namespace std;
        int a, b;
    
        cout << "Enter two integers: ";
        cin >> a >> b;//!!!第一次这么用
        int c = (a > b ? a : b);
        cout << "The bigger of " << a << " and " << b << " is " << c << endl;
        return 0;
    }

Enter two integers: 23 45
    The bigger of 23 and 45 is 45

# switch语句（可以从大型列表中选择，但不可以处理取值范围） #

switch只可以处理单个值，不可以像if else那样处理取值范围；并且switch的数必须是整数，所以没法处理浮点测试。

但是如果不涉及取值范围和浮点数，所有选项可以用整型常量表示，那么switch语句的效率是远远高于if语句的，（在LeetCode题感受到了），选项越多越明显

switch后面的括号的表达式必须是整型表达式，而且每一个标签都必须是整型常量表达式，最常用char int；

default语句是可选的，没有匹配标签程序就直接执行switch后面的语句了。

注意，case后面的这些标签都是行标签，他们表示了这行代码的地址，所以程序跳到某行后，如果没有break，就会从这个标签开始一直顺序往后执行。也就是说，case的标签很像go to语句的跳转，跳过去就从那里开始往后执行代码了。

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

## 示例1 char int做标签 ##

#include <iostream>
    void report();
    void comfort();
    void showmenu();
    using namespace std;
    
    int main()
    { 
        showmenu();
        int choice;
        cin >> choice;
        while (choice != 5)
        { 
            switch(choice)
            { 
            case 1:
                cout << '\a';
                break;
            case 2:
                report();
                break;
            case 3:
                cout << "The boss was in all day.\n";
                break;
            case 4:
                comfort();
                break;
            default:
                cout << "That is not a choice!\n";
                break;
            }
            showmenu();
            cin >> choice;
        }
        cout << "Bye!\n";
    
        return 0;
    }
    
    void showmenu()
    { 
        cout << "Please enter 1, 2, 3, 4 or 5:\n"
             << "1)alarm 2)report\n"
             << "3)alibi 4)comfort\n"
             << "5)quit\n";
    }
    
    void report()
    { 
        cout << "Sales are up 120%. Expenses are down 35%.\n";
    }
    
    void comfort()
    { 
        cout << "Your employees think you are the finest boss in the industry.\n";
    }

输出我就不显示了。总之是正确的

### 输入缓冲很会制造麻烦 ###

但是，实际上上面这段代码的漏洞很危险。即当用户不老老实实输入数字选项时，程序会死循环！！！

因为choice是int类型，你输入字符，反正只要不是数字，choice就会被置为0，并且**那个字符会一直停留在输入缓冲中**，于是不断循环，但是那个字母永远都在输入队列中，于是就死循环了，，，，，输入缓冲还挺会制造麻烦的！

## 把标签改为字母更好 ##

因为如果用字母而不是数字来 switch, 就算输入了数字也会被当作一个字符

然后把上面的int数字改为字符，竟然并不顺利，原因还是在于cin.get(char)留下了换行符！！

#include <iostream>
    void report();
    void comfort();
    void showmenu();
    using namespace std;
    
    int main()
    { 
        showmenu();
        char choice;
        cin.get(choice);
        cin.get();//读换行符
        while (choice != 'q' && choice != 'Q')
        { 
            switch(choice)
            { 
            case 'a':
            case 'A':
                cout << '\a';
                break;
            case 'r':
            case 'R':
                report();
                break;
            case 'B':
            case 'b':
                cout << "The boss was in all day.\n";
                break;
            case 'c':
            case 'C':
                comfort();
                break;
            default:
                cout << "That is not a choice!\n";
                break;
            }
            showmenu();
            cin.get(choice);
            cin.get();
        }
        cout << "Bye!\n";
    
        return 0;
    }
    
    void showmenu()
    { 
        cout << "Please enter a, r, b, c or q:\n"
             << "a)alarm r)report\n"
             << "b)alibi c)comfort\n"
             << "q)quit\n";
    }
    
    void report()
    { 
        cout << "Sales are up 120%. Expenses are down 35%.\n";
    }
    
    void comfort()
    { 
        cout << "Your employees think you are the finest boss in the industry.\n";
    }

我试了，就算输入数字，也不会像上面那样进入死循环！！！太美丽了

## 示例2 enum枚举量做标签 ##

#include <iostream>
    enum { red, orange, yellow, green, blue, violet, indigo};//没有名称的枚举类型，只是用于定义符号常量
    int main()
    { 
        using namespace std;
        cout << "Enter a code (0-6): ";
        int code;
        cin >> code;
        while (code >= red && code <= indigo)
        { 
            switch(code)
            { 
            case red:
                cout << "Her lips are red.\n";
                break;
            case orange:
                cout << "Her hair is orange.\n";
                break;
            case yellow:
                cout << "Sunflowers are yellow.\n";
                break;
            case green:
                cout << "Grass is green.\n";
                break;
            case blue:
                cout << "Jeans are blue.\n";
                break;
            case violet:
                cout << "Her eyes are violet.\n";
                break;
            case indigo:
                cout << "Her mood is indigo.\n";
                break;
            }
            cout << "Enter a code (0-6): ";
            cin >> code;
        }
    
        return 0;
    }

Enter a code (0-6): 0
    Her lips are red.
    Enter a code (0-6): 3
    Grass is green.
    Enter a code (0-6): 4
    Jeans are blue.
    Enter a code (0-6): 6
    Her mood is indigo.
    Enter a code (0-6): 1
    Her hair is orange.
    Enter a code (0-6): 7

# break continue #

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

## 示例 回显字符 ##

#include <iostream>
    const int Arsize = 81;
    int main()
    { 
        using namespace std;
        char line[Arsize];
    
        cout << "Enter a line of text:\n";
        cin.get(line, Arsize);
        cout << "Complete line:\n" << line << endl;
        cout << "Line through the first period:\n";//第一个句号之前的内容
        int i;
        int spaces = 0;//第一个句号前的空格数
        for (i = 0; line[i] != '\0'; ++i)
        { 
            cout << line[i];
            if (line[i] == '.')
                break;
            if (line[i] != ' ')
                continue;
            ++spaces;//不需要else，因为continue会跳过后面的代码，直接进入下一次循环
        }
        cout << endl << spaces << " spaces.\n";
        return 0;
    }

Enter a line of text:
    Let's do lunch today. You will pay!
    Complete line:
    Let's do lunch today. You will pay!
    Line through the first period:
    Let's do lunch today.
    3 spaces.

# C++也认为直接不要用goto语句 #

C++也有goto语句，但是和C一样，建议不要用goto，用if else ,switch, break ,continue等等就足够了

# 示例 输入类型错误 和 EOF导致cin返回false，clear()重置错误标记 #

如果输入的接收对象和输入的数据不是同类型，比如输入字符，接收类型是double，这样**cin对象的一个错误标记**就会被标记，并且把cin对象转换为bool类型会得到false，错误的输入会被继续留在输入队列。

看来cin对象有很多错误标记咯

#include <iostream>
    const int Arsize = 5;
    
    int main()
    { 
        using namespace std;
        double fishWeight[Arsize] = { };
        cout << "Enter the weights of fish today: (enter any nonnumeric character to end the input)\n";
        int i = 0;
    
        while (i < Arsize && cin >> fishWeight[i])//很棒的判断条件
        //cin>>fishWeight[i]实际上也是cin的一个方法调用，返回cin对象，如果cin在测试条件中就会被自动转换为bool
        //一定要明白&&两侧的布尔表达式是不平等的，左边的更高级，因为一旦左边的可以决定结果，右边的就根本不会被判定
        //所以要把最重要的条件放在最左边，依次序向右
        { 
            ++i;
        }//退出while后有i条鱼
        if (i)
        { 
            cout << "You caught " << i << " fish!\n";
            cout << "Weights: ";
            while (--i)//i条鱼，但是得从i-1到0,倒序输出重量
            { 
                cout << fishWeight[i] << ' ';
            }
            cout << fishWeight[i] << ' ';//i=0不会进入上面的循环
        }
        else
            cout << "No fish!\n";
    
        return 0;
    }

不小心输入了中文句号，当然输入也会结束

cin>>fishWeight\[i\]实际上也是cin的一个方法调用，返回cin对象，如果cin在测试条件中就会被自动转换为bool

Enter the weights of fish today:
    (enter any nonnumeric character to end the input)
    1.23 3。4 6.1 7.2 s
    You caught 2 fish!
    Weights: 3 1.23

修改：（使得获得错误输入后可以修正，继续输入，而不是直接结束循环）

#include <iostream>
    const int Arsize = 5;
    
    int main()
    { 
        using namespace std;
        double fishWeight[Arsize] = { };
        cout << "Enter the 5 weights of fish today:\n";
    
        int i;
        for (i = 0; i < Arsize; ++i)
        { 
            cout << "fish #" << i + 1 << ": ";
            while (!(cin >> fishWeight[i]))
            { 
                //输入错误则提醒用户，并复位输入（重启输入），提醒用户再次输入
                cin.clear();//clear()方法只是复位错误标记，不会把输入队列清空
                cout << "Wrong input! Please enter again...\n";
                //把刚才的错误输入读取掉，不然使得这个while死循环······
                //这里和C的我写的eatline()函数一样，把直到换行符前面的所有错误输出读掉
                while(cin.get() != '\n')
                    ;
                continue;//不加这句就不会再让用户输入！
            }
        }
    
    
        cout << "Weights: ";
        while (--i)//i条鱼，但是得从i-1到0,倒序输出重量
        { 
            cout << fishWeight[i] << ' ';
        }
        /* //上面的while写成这样更加简洁 while (i)//i条鱼，但是得从i-1到0,倒序输出重量 { cout << fishWeight[--i] << ' '; } */
        cout << fishWeight[i] << ' ';//i=0不会进入上面的循环
    
        return 0;
    }

Enter the 5 weights of fish today:
    fish #1: 2
    fish #2: a
    Wrong input! Please enter again...
    3
    fish #3: 4
    fish #4: f
    Wrong input! Please enter again...
    6
    fish #5: 1
    Weights: 1 6 4 3 2

其中控制输入正确的这段代码是核心

while (!(cin >> fishWeight[i]))
    { 
        //输入错误则提醒用户，并复位输入（重启输入），提醒用户再次输入
        cin.clear();//clear()方法只是复位错误标记，不会把输入队列清空
        cout << "Wrong input! Please enter again...\n";
        //把刚才的错误输入读取掉，不然使得这个while死循环······
        //这里和C的我写的eatline()函数一样，把直到换行符前面的所有错误输出读掉
        while(cin.get() != '\n')
            ;
        continue;//不加这句就不会再让用户输入！
    }

[20200303144046994.png]: https://img-blog.csdnimg.cn/20200303144046994.png
[20200303144026440.png]: https://img-blog.csdnimg.cn/20200303144026440.png
[20200303182141378.png]: https://img-blog.csdnimg.cn/20200303182141378.png
[20200303182211109.png]: https://img-blog.csdnimg.cn/20200303182211109.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200303182357104.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200303182420959.png]: https://img-blog.csdnimg.cn/20200303182420959.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020030321392871.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/20200303214956322.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/20200303230725375.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70