C++笔记：变量作用域

淩亂°似流年 2021-12-09 07:55 398阅读 0赞

### 文章目录 ###

*  概述
 *  四种变量的存储类别
 *   *  auto变量
     *  static变量
     *  register变量
     *  extern变量

# 概述 #

一、在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区  
1.栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。  
2.堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。  
3.自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。  
4.全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。  
5.常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改）  
二、变量的作用域  
在函数内定义的变量为局部变量，在函数体外定义的变量为全局变量。变量都有它的生命期，全局变量在程序开始时创建并分配空间，在程序结束的时候释放内存并销毁；局部变量在函数调用时  
创建，并在栈内存中分配内存，在函数调用结束后销毁并释放。  
三、变量的存储类别  
存储类别是变量的属性之一，C++语言定义了4种变量的存储类别，分别是auto变量，static变量，register变量和extern变量。变量存储方式不同会使变量的生存期不同，生存期表示变量存在的  
时间。生存期和作用域是从时间和空间这两个不同角度来描述变量的特性。静态存储变量通常是在变量定义时就分配固定的存储单元并一直保持不变，直到整个程序结束。全局变量即属于此类存  
储方式，它们存储在静态存储区。动态存储变量是在程序执行过程中使用它时才分配存储单元，使用完毕后立即将该存储单元释放。如函数定义的形式参数，在函数定义时并不给形参分配存储单元  
，只是在函数被调用时才给予分配，调用函数完毕后立即释放，此类变量存储在动态存储区。

# 四种变量的存储类别 #

## auto变量 ##

auto变量：  
自动变量存储类型是C++语言程序中默认的存储类型。函数内未加存储类型说明的变量均视为自动变量，自动变量可省略关键字auto。其有如下特点：  
1、自动变量的作用域仅限于定义该变量的个体内（函数中定义的自动变量，只在该函数内有效。在复合语句中定义的自动变量只在该复合语句有效）。  
2、自动变量属于动态存储方式，变量分配的内存在栈中，在函数调用结束后，自动变量的值会被释放；在复合语句中定义的自动变量，在退出复合语句后也不能再使用。  
3、在不同的个体(函数或复合语句)内允许使用同名的变量而不混淆，即使在函数内定义的自动变量也可与该函数内部的复合语句中定义的自动变量同名。

#include<iostream>
    using namespace std;
    void Show(){ 
     int x,y;//Show函数内定义的局部整形变量x,y
     x=1;
     y=2;
     if(true){ 
      char ch;//if复合语句内定义字符变量ch
      ch='a';
      cout<<ch<<endl;
      cout<<x<<endl;
      cout<<y<<endl;
     }
    }
    int main(){ 
     Show();
     return 0;
    }

输出：  
![在这里插入图片描述][20190716165011169.PNG]  
在Show函数内的if复合语句可以访问自己作用域内的字符变量ch，还可以访问Show函数内定义的整形变量x和y  
但如果在if语句内改变x,y的值呢？

输出：

![在这里插入图片描述][20190716165046120.PNG]

然后再在if复合语句外再访问x,y变量，是否改变？

#include<iostream>
    using namespace std;
    void Show(){ 
     int x,y;//Show函数内定义的局部整形变量x,y
     x=1;
     y=2;
     if(true){ 
      char ch;//if复合语句内定义字符变量ch
      ch='a';
      x=3;
      y=4;
      cout<<ch<<endl;
      cout<<x<<endl;//在复合语句中访问x
      cout<<y<<endl;//在复合语句中访问y
     }
     cout<<x<<endl;//在复合语句外访问x
     cout<<y<<endl;//在复合语句外访问y
     
    }
    int main(){ 
     Show();
     return 0;
    }

输出：

![在这里插入图片描述][20190716165416990.PNG]

由于自动变量（auto为默认变量存储类型，可缺省）x,y在函数Show内定义，所以在整个函数内都可访问修改到。此时在if复合  
语句内定义与Show函数同名的自动变量x,y。

#include<iostream>
    using namespace std;
    void Show(){ 
     int x,y;//Show函数内定义的局部整形变量x,y
     x=1;
     y=2;
     if(true){ 
      int x,y;//if复合语句内定义与Show函数同名整形变量x,y
      char ch;//if复合语句内定义字符变量ch
      ch='a';
      x=3;
      y=4;
      cout<<ch<<endl;
      cout<<x<<endl;//在复合语句中访问x
      cout<<y<<endl;//在复合语句中访问y
     }
     cout<<x<<endl;//在复合语句外访问x
     cout<<y<<endl;//在复合语句外访问y
     
    }
    int main(){ 
     Show();
     return 0;
    }

输出：

![在这里插入图片描述][2019071617421489.PNG]  
 此处代码与上一处代码最大的不同就是，在if复合语句中重新定义了x,y，重新赋值，相当于在另外一个动态存储区存放x,y自动变量的值，即Show函数内定义的x,y与if复合语句内定义的x,y存储在不同的动态存储区，而上一处代码中，if语句内没有定义x,y变量，所以操作的还是Show函数存放在动态存储区的x,y自动变量

但由于字符变量ch是在if复合语句内定义，所以自动变量ch的生命周期（if复合语句执行完后，将不存在该ch变量）和  
作用域（if复合语句内）都局限于定义它的个体内（函数或者复合语句）。所以接下来在复合语句外访问字符变量ch，则会  
显示错误。

#include<iostream>
    using namespace std;
    void Show(){ 
     int x,y;//Show函数内定义的局部整形变量x,y
     x=1;
     y=2;
     if(true){ 
      char ch;//if复合语句内定义字符变量ch
      ch='a';
      x=3;
      y=4;
      cout<<ch<<endl;
      cout<<x<<endl;//在复合语句中访问x
      cout<<y<<endl;//在复合语句中访问y
     }
     cout<<x<<endl;//在复合语句外访问x
     cout<<y<<endl;//在复合语句外访问y
     cout<<ch<<endl;//在复合语句外访问复合语句内定义的ch变量，执行错误，显示该变量为定义
     
    }
    int main(){ 
     Show();
     return 0;
    }

输出：  
![在这里插入图片描述][20190716172022268.PNG]

符ch变量仅在if复合语句内有效。

## static变量 ##

菜鸟教程部分内容([https://www.runoob.com/w3cnote/cpp-static-usage.html][https_www.runoob.com_w3cnote_cpp-static-usage.html])  
1.1、static的引入  
我们知道在函数内部定义的变量，当程序执行到它的定义处时，编译器为它在栈内存上分配空间，函数内部定义的变量所分配的空间会在此函数执行结束时释放掉，这样就产生一个问题：如果想将函数中此变量的值保存至下一次调用时，如何实现？最容易想到的方法是定义为全局变量，但定义一个全局变量有许多缺点，最明显的缺点就是破坏了此变量的访问范围（使得在此函数中使用的变量不熟此函数控制）。而static关键字则可以很好的解决这个问题。  
另外，在C++中，需要一个数据对象为整个类而非某个对象服务，同时又力求不破坏类的封装性，即要求此成员隐藏在类的内部，对外不可见时，可将其定义为静态数据。  
1.2、静态数据的存储  
全局（静态）存储区：分为DATA段和BSS段。DATA段（全局初始化区）存放初始化的全局变量和静态变量；BSS段（全局未初始化区）存放未初始化的全局变量和静态变量。两段存储区在程序运行结束时自动释放。其中BSS段在程序执行之前会被系统自动清0，所以未初始化的全局变量和静态变量在程序执行之前已经为0。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一一次初始化。  
在C++中static的内部实现机制：静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。故静态数据成员内存空间分配出现在程序的main()函数前的全局数据声明和定义处。  
2、在C/C++中static的作用  
2.1、总结：  
（1）在修饰变量的时候，static修饰的静态局部变量只执行初始化一次，延长了局部变量的生命周期，直到程序运行结束后才释放。  
（2）static修饰全局变量时，这个全局变量只能在文件中访问，不能在其他文件中访问，即便是extern外部声明也不可以。  
（3）static修饰一个函数时，则这个函数只能在本文件中调用，不能被其它文件调用。static修饰的变量存放在全局数据区的静态变量区，包括全局静态变量和局部静态变量，都在全局数据区分配内存。初始化时自动初始化为0。  
(4)函数内的变量不想释放时，可以使用static修饰。比如修饰函数中存放在栈空间的数组。如果不想让这个数组在函数调用结束释放可以使用static修饰。  
考虑的数据的安全性（当程序想要使用全局变量时应优先考虑使用static）  
**静态全局变量有以下特点：**  
2.2、静态变量与普通变量  
(1)静态变量在全局数据区分配内存，包括静态局部变量  
(2)未经初始化的静态全局变量以及静态局部变量会被程序自动初始化为0；而在函数体内声明的自动变量的值是随机的，除非它被显式初始化，而在函数体外声明  
2.3、全局变量与全局静态变量  
（1）全局变量是不显式用static修饰的全局变量，全局变量默认有外部连接性，作用域是整个工程，在一个文件内定义的全局变量，在另一个文件内，可通过extern全局变量名的声明，就可以使用全局变量。  
（2）全局静态变量是显式用static修饰的全局变量，作用域是声明此变量所在的文件，其它文件即使使用extern声明也不能使用。  
**静态局部变量有以下特点：**  
（1）该变量在全局数据区分配内存。  
（2）静态局部变量在程序执行到该对象的声明处时被首次初始化，以后的函数调用不再初始化。  
（3）静态局部变量在声明处初始化，如果没有显式初始化，则自动初始化为0。  
（4）它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或者语句块结束时，其作用域随之结束。

使用static变量实现累加

#include<iostream>
    #include <windows.h>//用于函数SetConsoleOutputCP(65001);更改cmd编码为utf8
    using namespace std;
    int add(int x){ 
     static int n=0;//声明定义静态局部变量n，函数调用多次也只初始化一次，而且作用域仅限制于add函数内
     n=n+x;
     return n;//
    }
    int main(){ 
     int input,i,sum;
     SetConsoleOutputCP(65001);
     cout<<"请输入一个需要累加的数："<<endl;
     cin>>input;
     cout<<"结果是："<<endl;
     for(i=1;i<=input;i++){ 
      sum=add(i);
      cout<<i<<"->"<<sum<<endl;
     }
     return 0;
    }

输出：  
![在这里插入图片描述][20190717074107548.PNG]  
解释：  
主函数中for循环执行3次，第一次循环执行add函数传入实参1，静态局部变量n初始化为0(以后函数调用不再初始化),执行完后返回结果n=1，输出1->1。第二次循环执行add函数传入实参2，静态局部变量n为1，执行完后返回结果n=3。最后一次循环传入3与n=3相加，返回n=6。

## register变量 ##

一般情况下,变量的值是存放在内存中的｡当程序中用到哪一个变量的值时,由控制器发出指令将内存中该变量的值送到CPU中的运算器｡经过运算器进行运算,如果需要存数,再从运算器将数据送到内存存放｡

为提高执行效率,C++允许将局部变量的值放在CPU中的寄存器中,需要用时直接从寄存器取出参加运算,不必再到内存中去存取｡这种变量叫做寄存器变量,用关键字register作声明｡

以下代码转自 [https://blog.csdn.net/howard2005/article/details/79336293][https_blog.csdn.net_howard2005_article_details_79336293] ：普通变量与寄存器变量的速度对比

#include<iostream>//<>直接去系统目录中找
    #include <windows.h>//用于函数SetConsoleOutputCP(65001);更改cmd编码为utf8
    #include"time.h"//""首先在当前目录下寻找，如果找不到，再到系统目录中寻找 
    /* clock()是C/C++中的计时函数，而与其相关的数据类型是clock_t; 头文件：time.h/ctime clock()函数是c++库里的函数，它返回程序启动后经过的时钟节拍数，CLOCKS_PER_SEC 这个 宏扩展为一个表达式，表示一秒钟内时钟节拍数，由函数时钟返回。用这个表达式除以时钟 节拍数就得到秒数，单位为ms */
    using namespace std;
    int main(){ 
     SetConsoleOutputCP(65001);
     clock_t start,finish;
     start=clock();
     int i,sum=0;
     for(i=1;i<1000000000;i++){ 
      sum+=i;
     }
     finish=clock();
     cout<<"sum="<<sum<<endl;
     cout<<"耗时:"<<(double)(finish-start)/CLOCKS_PER_SEC*1000<<'s'<<endl;
     return 0;
    }

输出：  
![在这里插入图片描述][20190717082029639.PNG]

#include<iostream>//<>直接去系统目录中找
    #include <windows.h>//用于函数SetConsoleOutputCP(65001);更改cmd编码为utf8
    #include"time.h"//""首先在当前目录下寻找，如果找不到，再到系统目录中寻找 
    /* clock()是C/C++中的计时函数，而与其相关的数据类型是clock_t; 头文件：time.h/ctime clock()函数是c++库里的函数，它返回程序启动后经过的时钟节拍数，CLOCKS_PER_SEC 这个 宏扩展为一个表达式，表示一秒钟内时钟节拍数，由函数时钟返回。用这个表达式除以时钟 节拍数就得到秒数，单位为ms */
    using namespace std;
    int main(){ 
     SetConsoleOutputCP(65001);
     clock_t start,finish;
     start=clock();
     register int i,sum=0;//在此处加上register关键字
     for(i=1;i<1000000000;i++){ 
      sum+=i;
     }
     finish=clock();
     cout<<"sum="<<sum<<endl;
     cout<<"耗时:"<<(double)(finish-start)/CLOCKS_PER_SEC*1000<<'s'<<endl;
     return 0;
    }

输出:  
![在这里插入图片描述][20190717082322602.PNG]  
通常变量的值存放在内存中，当对一个变量频繁读取时，如上面两个代码片段对变量i和sum都需要上亿次的读取累加，反复访问内存存储器，花费大量的存取时间。故为了提高效率，C++语言可以将变量声明为寄存器变量，这种变量将局部变量的值存放在CPU寄存器，使用时不需要访问内存，直接从CPU寄存器中读写。  
对寄存器变量的说明：  
（1）寄存器变量属于动态存储方式（动态存储在程序执行过程中使用到它时才分配存储单元，使用完毕后立即将该存储单元释 放），凡需要采用静态存储方式的变量不能定义为寄存器变量。  
（2）编译器会自动决定哪个变量使用寄存器存储。register起到程序优化的作用。

## extern变量 ##

在一个源文件中定义的变量和函数只能被本文件中的函数调用，一个C++程序会有多个源文件，如果使用非本源文件呢？C++提供extern关键字来解决此问题。在使用其它源文件的全局变量时，只需要在本源文件中使用extern关键字来声明这个变量即可。  
该部分转自 [https://blog.csdn.net/ijn842/article/details/81196489][https_blog.csdn.net_ijn842_article_details_81196489]

**先来看一下同一源文件声明与定义的例子**：  
代码一

#include<stdio.h>
    int num=4;//定义变量num
    int func(){ //定义函数func
     printf("%d\n",num);
     return num;
    }
    int main(){ 
     func();
     printf("%d\n",num);
     return 0; 
    }

输出:  
![在这里插入图片描述][20190717103257542.PNG]  
此处在主函数前定义了全局变量num和函数func()，而在func()之前也定义了需要操作的num全局变量。但如果将int num=4;语句写在func()函数与main()函数之间会怎么样？

代码二

#include<stdio.h>
    int func(){ //定义函数func
     printf("%d\n",num);
     return num;
    }
    int num=4;//定义变量num
    int main(){ 
     func();
     printf("%d\n",num);
     return 0; 
    }

输出：  
![在这里插入图片描述][20190717104254365.PNG]

显示错误：“num”没有在此范围中声明，但还是显示了结果。因为func()函数在执行的时候，num变量在func()函数定义之后定义。而main()函数在执行的时候num变量在其之前定义，故正常编译通过。如果非要这么写怎么办？下文可用extern关键字解决。

代码三

#include<stdio.h>
    int num;//定义全局变量num，注意int num与int num=4都属于变量的定义,而extern int num则属于变量的声明
    int func();//声明func函数
    int main(){ 
     func();
     printf("%d\n",num);
     return 0; 
    }
    int func(){ 
     printf("%d\n",num);
     return num;
    }

代码一与代码二都是在main函数之前就定义好的了，所以main函数直接就可操作，此处需要扩展一下int num;语句,该语句并非全局变量num的声明，很多时候，声明和定义是合而为一的，声明告诉编译器，这个变量或函数已经在程序其他地方存在了，所以我正在把这个信息告诉你，下面我要调用的时候请放行。但请不要为我分配任何内存空间，因为已经这个步骤在变量或函数定义的地方进行分配了  
而定义则很清楚了，就是要求分配内存空间。  
输出：  
![在这里插入图片描述][20190717105302251.PNG]

为什么？首先该变量定义在函数外，故为全局变量，而全局定义时没有赋初值，编译器自动为其赋值0；区分局部变量，若在函数内定义的变量（局部变量）时没有赋初值，编译器则赋一个随机数。

在执行main函数时，func函数虽然在其后定义，但在其之前有过func函数的声明，故编译器会在其他地方寻找函数定义处，而全局变量在main函数和func函数之前有定义，故两个函数都可访问得到。代码四类似代码二，将定义全局变量num语句放在main函数与func函数中间  
代码四

#include<stdio.h>
    int func();//声明func函数
    int main(){ 
     func();//此处由于有了func函数的声明，即便func函数的定义写在main函数后面,编译器仍能找到func函数的定义
     printf("%d\n",num);
     return 0; 
    }
    int num;//定义全局变量num，注意int num与int num=4都属于变量的定义,而extern int num则属于变量的声明
    int func(){ 
     printf("%d\n",num);
     return num;
    }

输出：  
![在这里插入图片描述][20190717110229907.PNG]  
由于定义全局变量num的语句放在main函数之后，func函数之前，故在执行main函数的打印语句时找不到全局变量num的声明定义，而func函数找的到。  
  
接着在使用extern关键字之前，先了解一下它的作用：  
在C语言中，修饰符extern用在变量或者函数的声明前，用来说明“此变量/函数是在别处定义的，要在此处引用”。extern声明不是定义，即不分配存储空间。  
对于函数来说，我们已经很清楚如何对其进行声明和定义的分离了，这正是我们在成对的 .h/.cpp 中做的事情，这里补充一句，实际上编译器对所有函数的声明和定义都悄悄在前面补上了 extern，因为 extern 代表了声明的动作，当我们包含一个头文件的时候，告诉编译器，我接下来调用到的函数是在它处进行定义的。  
那么变量的声明和定义如何分离呢？因为我们大多数时候都是既声明又定义一个变量的，如:

int num;//变量定义,编译器自动赋初值

这里虽然没有给num赋任何初值，但是在此处已经完成内存分配了。前面说过，extern关键词是用作声明的，因此我们可以这样做:

extern int num;//变量声明

此处才是对num的声明   将变量的声明与定义赋值分离写可以这样写：

extern int num;//变量声明
    int num = 100;//变量定义赋值

或者

extern int num = 0;//声明，定义，赋初值

就是同时声明与定义了，这时这里的extern则是冗余，可写可不写。

代码五

#include<stdio.h>
    int main(){ 
     extern int func();
     extern int num;
     func();
     printf("%d\n",num);
     return 0;
    }
    int func(){ 
     extern int num;
     printf("%d\n",num);
     return num;
    }
    int num=4;

输出:  
![在这里插入图片描述][20190717112839727.PNG]  
此处 extern int func();语句与extern int num;语句利用extern关键字先声明一下num变量与func函数，告诉编译器num这个变量与func这个函数是存在的，但不是在这之前声明的，你到别的地方找找吧，果然，这样就可以顺利通过编译啦。但是你要是想欺骗编译器也是不行的，比如你声明了extern int num；但是在后面却没有真正的给出num变量的声明，那么编译器去别的地方找了，但是没找到还是不行的。  
好了，我们修改代码二与代码四让其通过编译  
修改后的代码二

#include<stdio.h>
    int func(){ //定义函数func
     extern int num;//加上extern关键字的num声明
     printf("%d\n",num);
     return num;
    }
    int num=4;//定义变量num
    int main(){ 
     func();
     printf("%d\n",num);
     return 0; 
    }

修改后的代码四

#include<stdio.h>
    int main(){ 
     extern int num;//加上extern关键字的num声明
     extern int func();//加上带关键字extern的func函数声明
     func();
     printf("%d\n",num);
     return 0; 
    }
    int num;//定义全局变量num，注意int num与int num=4都属于变量的定义,而extern int num则属于变量的声明
    int func(){ 
     printf("%d\n",num);
     return num;
    }

**extern这个关键字的真正的作用是引用不在同一个文件中的变量或者函数**：

在VS 2019中新建一个Test项目，在源文件夹中新建main.cpp和fun.cpp两个c++源文件  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjEyNDIzNA_size_16_color_FFFFFF_t_70]

fun.cpp源代码为：

#include<stdio.h>
    int num = 5;
    void func() { 
     printf("func in fun.c");
    }

解释：此处在fun.cpp中定义了一个变量num（注意：只有当一个变量是全局变量时，extern变量才会起作用）和函数func()  
在main.cpp中的main函数中都先用extern int num;和extern void func();声明此num变量和func函数在外部文件定义，然后在后面调用函数以及打印变量时，编译器会到外部文件寻找num变量与func()函数的定义。

单击"本地Windows调试器"选项  
输出：  
![在这里插入图片描述][20190717170913321.PNG]  
此处需要注意几点：

*  在main.cpp文件中对于引入num外部全局变量，extern关键字只需要指明类型和变量名就行了，不能进行定义赋值操作
 *  num全局变量需要在原文件所在处进行初始化，如果忘记初始化，编译器会自动为全局变量初始化为0
 *  在用extern声明num变量后就可以对变量进行修改了，***见下面的代码***

main.cpp

#include<stdio.h>
    int main() { 
     extern int num;
     extern void func();
     func();
     num = 1;//修改变量num值
     printf("\n%d",num);
     return 0;
    }

![在这里插入图片描述][20190717172041146.PNG]

*  使用include将另一个文件全部包含进去可以引用另一个文件中的变量，但这样做的坏处是，被包含文件中所有的变量和函数都可以被这个文件所使用，显得不安全，如果只是希望一个文件使用另一个文件中的某个变量还是使用extern关键字更好。

[20190716165011169.PNG]: /images/20211208/b4d6aade0ee74736a3087d4481040e8b.png
[20190716165046120.PNG]: /images/20211208/1a1a5b940bb844148957db2c5c4e78ca.png
[20190716165416990.PNG]: /images/20211208/e44e251375c947cebcb096180cee1361.png
[2019071617421489.PNG]: /images/20211208/abaddcf7130847f9aafc20811f29e8c1.png
[20190716172022268.PNG]: /images/20211208/bdef0890611d45ff87efdaebf8e90dae.png
[https_www.runoob.com_w3cnote_cpp-static-usage.html]: https://www.runoob.com/w3cnote/cpp-static-usage.html
[20190717074107548.PNG]: /images/20211208/db499ccb82704bfcb22efd21d25bc0a6.png
[https_blog.csdn.net_howard2005_article_details_79336293]: https://blog.csdn.net/howard2005/article/details/79336293
[20190717082029639.PNG]: /images/20211208/00ca82356dcf46188fafb2b06338fb36.png
[20190717082322602.PNG]: /images/20211208/0f6e8853d861409b96a4b1356cfa75be.png
[https_blog.csdn.net_ijn842_article_details_81196489]: https://blog.csdn.net/ijn842/article/details/81196489
[20190717103257542.PNG]: /images/20211208/87da6db436dc498882dfe2435b661de5.png
[20190717104254365.PNG]: /images/20211208/a81189459f3444249a8ba8dd92be9efa.png
[20190717105302251.PNG]: /images/20211208/5c11cf3d27164c63a8350e96dd39a033.png
[20190717110229907.PNG]: /images/20211208/71c5226b2b414987b2c64cdf63ccbdc8.png
[20190717112839727.PNG]: /images/20211208/0b347067d2134178a8090ebf9de98848.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjEyNDIzNA_size_16_color_FFFFFF_t_70]: /images/20211208/553d386c3f324835af6a0769ce75b5fc.png
[20190717170913321.PNG]: /images/20211208/c6b57e4d7c2a4ac5af82618d68d314d9.png
[20190717172041146.PNG]: /images/20211208/cfab2c701d0244129f288f6f66fe7cf2.png