106-C++学习第二弹(入门基础)

悠悠 2022-12-29 06:36 115阅读 0赞

## C++学习 ##

## ***1.类与对象*** ##

封装（Encapsulation）是面向对象程序设计最基本的特性，把数据（属性）和函数（操作）合成一个整体，这在计算机世界中是用类与对象实现的。  
**C++中类的设计：**  
在 C++中，类是一种数据类型。  
客观事物是复杂的，要描述它必须从多方面进行，也就是用不同的数据类型来描述不同的方面。  
如商场中的商品可以这样描述：  
商品名称（用字符串描述），该商品数量（用整型数描述），该商品单（用浮点数描述），该商品总价（用浮点数描述）。  
这里用了属于三种不同数据类型的四个数据成员（data member）来描述一种商品

class CGoods
    {
        
    public:
    	char Name[21];
    	int Amount;
    	float Price;
    	float Total_value;
    }; //最后的分号不可少，这是一条说明语句

关键字 **class** 是数据类型说明符，指出下面说明的是类。标识符 CGoods 是商品这个类的类型名。花括号中是构成类体的一系列的成员，关键字 public 是一种访问限定符。  
**访问限定符**有三种：public（公共的），private（私有的）和 protected（保护的）。第一种说明的成员能从外部进行访问，另外两种说明的成员不能从外部进行访问。  
每种说明符可在类体中使用多次。它们的作用域是从该说明符出现开始到下一个说明符之前或类体结束之前结束。  
如果在类体起始点无访问说明符，系统默认定义为私有（private）。访问说明符 private（私有的）和protected（保护的）体现了类具有封装性

class CGoods
    {
        
    public:
    	char Name[21];
    	int Amount;
    	float Price;
    	float Total_value;
    };
    int g_max;
    CGoods ca;
    //以上两个为全局变量，在数据区，系统默认初始化均为0
    int main()
    {
        
    	int a=10;//给a分配空间
    	CGoods c1;//定义c1这个对象了，才能给对象分配空间
    	return 0;
    }

关于全局变量的值  
![在这里插入图片描述][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]

class 类名
    {
        
    public:
    	成员列表 1;
    protected:
    	成员列表 2;
    private:
    	成员列表 3;
    };//最后的分号不可少;注意：所有说明都有分号

其中“class 类名”称为类头（class head）。花括号中的部分称为类体（class body），类体中定义了类成员表（class member list）  
**对象的属性能访问和不能访问 取决于 你自己设计的类型 你如何去设计这个类型**  
**类型最终要实例化成对象**  
类型设计的更关键部分是对数据成员的操作，用函数来完成：

这样在类中引进了成员函数(member function)或函数成员,也就是函数也成了数据(类)中的一员。类把数据（事物的属性）和函数（事物的行为–操作）封装为一个整体  
四个数据成员被说明成私有，而六个函数成员被说明成公有；这就是说如果从外部对四个数据成员进行操作的话,只能通过六个公有函数来完成，数据受到了良好的保护，不易受副作用的影响。公有函数集定义了类的接口（interface）  
**类是一种数据类型，设计一个类型时系统不为类分配存储空间**，所以不能对类的数据成员初始化。类中的任何数据成员也不能使用关键字 extern、auto 或 register 限定其存储类型  
成员函数可以直接使用类定义中的任一成员，可以处理数据成员，也可调用函数成员。  
成员函数的定义：  
前面只对成员函数作了一个声明（函数的原型），并没有对函数进行定义。  
函数定义通常在类的说明之后进行，其格式如下：  
回值类型 类名::函数名(参数表)  
\{……\}//函数体  
其中运算符“::”称为作用域解析运算符(scope resolution operator)，它指出该函数是属于哪一个类的成员函数。  
**类内函数的声明和类外函数的定义要保持一致**

class CGoods
    {
        
    private:
    	char Name[21];
    	int Amount;
    	float Price;
    	float Total_value;
    public:
    	void RegisterGoods(char[], int, float); //输入数据
    	void CountTotal(void); //计算商品总价值
    	void GetName(char[]); //读取商品名
    	int GetAmount(void); //读取商品数量
    	float GetPrice(void); //读取商品单价
    	float GetTotal_value(void) //读取商品总价值
    	//类内声明，类内定义，系统直接默认为该类的成员函数
    	{
        
    		return Total_value;
    	}
    };
    //类内声明，类外定义，需要在函数名前加上 类::  CGoods::
    //::作用域解析运算符
    void CGoods::RegisterGoods(char name[], int amount, float price)
    {
        
    	strcpy(Name, name); //字符串拷贝函数
    	Amount = amount;
    	Price = price;
    }
    void CGoods::CountTotal(void)
    {
        
    	Total_value = Price * Amount;
    }
    void CGoods::GetName(char name[])
    {
        
    	strcpy(name, Name);
    }
    int CGoods::GetAmount(void) {
         return(Amount); }
    float CGoods::GetPrice(void) {
         return(Price); }
    //float CGoods::GetTotal_value(void) { return(Total_value); }

**类内声明且类内定义 和 类内声明类外定义 两者的区别**  
**类内声明且类内定义** 它默认inline函数  
**类内声明类外定义** 它就不是inline内联函数 要想让它成为inline函数就要在它的声明和定义前面都加上 inline关键字

***对象的创建与使用***  
对象是类的实例（instance）。声明一种数据类型只是告诉编译系统该数据类型的构造，并没有预定内存。类只是一个样板（图纸），以此样板可以在内存中开辟出同样结构的实例–对象。  
**创建类的对象可以有两种常用方法**  
第一种是直接定义类的实例–对象

int a;
    CGoods Car;

这个定义创建了 CGoods 类的一个对象 Car，同时为它分配了属于它自己的存储块，用来存放数据和对这些数据实施操作的成员函数（代码）。对象只在定义它的域中有效。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]  
**这三个对象的生存空间和生存期各不一样**  
进入到主函数之前，系统已经构建了s1对象，在数据区  
进入主函数，给主函数分配了栈帧，然后依次a=10,c1这个对象，指针cp，从堆区new了一个CGoods的空间，然后构造这个对象，把对象这个地址给cp，用完这个对象，delete cp; **new产生的对象的生存期由程序员控制**，但是s1的生存期程序员控制不了，主函数结束 程序结束 s1才结束，c1对象在调用主函数时产生，函数结束，分配给函数的栈空间结束，c1才结束，**s1 c1都由系统控制**。

int main()
    {
        
    	CGoods tea;
    	CGoods book;
    	tea.RegisterGoods("black_tea", 12, 560);
    	tea.CountTotal();
    	book.RegisterGoods("Thinking In C++", 20, 128);
    	book.CountTotal();
    	return 0;
    }

对象使用的规则很简单，只要在对象名后加点号（点操作符，成员访问运算符(member access oprator)之一），再加成员数据或成员函数名就可以了。但是这些成员必须是公有的成员，只有公有成员才能在对象的外面对它进行访问。  
**C++对象模型讨论**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]  
上图是系统为每一个对象分配了全套的内存，包括安放成员数据的数据区和安放成员函数的代码区。但是区别同一个类所实例化的对象，是由属性（数据成员）的值决定，不同对象的数据成员的内容是不一样的；而行为（操作）是用函数来描述的，这些操作的代码对所有的对象都是一样的。这样去开辟对象，占用内存太大。每个对象的区别不是靠方法区别的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]  
上图仅为每个对象分配一个数据区，代码区（放成员函数的区域）为各对象类共用。

**当 tea.RegisterGoods(“black\_tea”, 12, 560); book.RegisterGoods(“Thinking In C++”, 20, 128);  
RegisterGoods 函数是怎样知道处理的是 tea 还是 book 的数据呢？**  
最根本的问题，系统是如何办到的？？？  
**答：**

编译器在对类型编译的时候，一共分为3次编译方案，编译3次。  
**第一次编译**时，扫描这个类型时候，把属性记录在案（不管这个属性放在类体的最后，中间还是最前面），记录这些数据成员的名称和类型，char Name\[21\];int Amount;float Price;float Total\_value;  
**第二次编译** 扫描函数，记录函数的原型（返回类型，函数名，参数类型，参数个数），设计函数的顺序无关紧要（与C语言不同之处），前面调用，后面定义，也可以成功。因为第二次编译，要把所有函数原型记录在案  
**第三次编译**（最关键的步骤）改写函数，看到函数的定义，相应地进行改写，给所有成员函数的声明加了一个参数：CGoods \*this 改写完函数的声明之后，然后走到函数的定义，扫描时发现，这个名字与扫描函数时的属性相同，对应关系，在名称前加上this->，不加this->系统给你加，你自己加->this,系统就不给你加。CGoods \*this 让系统加，自己不能加。  
**调用哪一个对象，把该对象的地址传进去**  
**靠消耗一个指针换来空间**

class CGoods
    {
        
    private:
    	char Name[21];
    	int Amount;
    	float Price;
    	float Total_value;
    public:
    	//void RegisterGoods(CGoods * const this,char [],int,float);
    	void RegisterGoods(char[], int, float);
    	//void CountTotal(CGoods * const this);
    	void CountTotal();
    };
    //void CGoods::RegisterGoods(CGoods * const this,char name[], int amount, float price);
    void CGoods::RegisterGoods(char name[], int amount, float price)
    {
        
    	strcpy(this->Name, name);
    	this->Amount = amount;
    	this->Price = price;
    }
    // void CGoods::CountTotal(CGoods * const this);
    void CGoods::CountTotal()
    {
        
    	this->Total_value = this->Price * this->Amount;
    }
    int main()
    {
        
    	CGoods tea;
    	CGoods book;
    	tea.RegisterGoods("black_tea", 12, 560);
    	// RegisterGoods(&tea,"black_tea",12,560);
    	tea.CountTotal();
    	// CountTotal(&tea);
    	book.RegisterGoods("Thinking In C++", 20, 128);
    	// RegisterGoods(&book,"Thinking In C++",20,128);
    	book.CountTotal();
    	// CountTotal(&book);
    	return 0;
    }

this指针在成员方法，对象里没有this指针，成员方法被调动this指针显现，成员方法不调动，this指针不显现，this指针就是当前对象的地址  
this指针不能修改，更不能赋值成NULL，系统不允许。  
CGoods \* const this  
![在这里插入图片描述][20201220213127678.png_pic_center]

## ***构造函数和析构函数*** ##

数据成员多为私有的，要对它们进行初始化，必须用一个公有函数来进行。同时这个函数应该在且仅在定义对象时自动执行一次。称为构造函数（constructor） 。  
构造函数用途：1）创建对象，2）初始化对象中的属性，3）类型转换。  
**构造函数是特殊的公有成员函数**（在特殊用途中构造函数的访问限定可以定义成私有或保护），**其特征如下：**  
1.函数名与类名相同。  
2.构造函数无函数返回类型说明。注意是没有而不是 void，即什么也不写，也不可写 void。实际上构造函数有返回值，返回的就是构造函数所创建的对象。  
3.在程序运行时，当新的对象被建立，该对象所属的类构造函数自动被调用，在该对象生存期中也只调用这一次。  
4.构造函数可以重载。严格地讲，类中可以定义多个构造函数，它们由不同的参数表区分，系统在自动调用时按一般函数重载的规则选一个执行。  
5.构造函数可以在类中定义，也可以在类中声明，在类外定义。  
6.如果类说明中没有给出构造函数，则 C++编译器自动给出一个缺省的构造函数:  
类名(void) \{ \}  
但只要我们定义了一个构造函数，系统就不会自动生成缺省的构造函数。只要构造函数是无参的或者只要各参数均有缺省值的，C++编译器都认为是缺省的构造函数，并且缺省的构造函数只能有一个 。

**C与C++最大的一个区别** **存储空间与对象的关系**  
C：有空间即可操作。主函数运行，主函数定义一个整型变量a，分配4个字节，这4个字节分配后，这4个字节就变成a,就可以对a操作。定义的变量就是整个空间，这个空间代表着这个变量  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]  
C++：空间是空间，对象是对象。C++中，首先申请空间，然后调动类型的构造函数，在空间中拿构造函数构建对象。空间和对象是分离的。有空间不一定有对象，有对象一定有空间。

class Object
    {
        
    private:
    	int count;
    	float price;
    public:
    	Object() {
        } // 缺省构造函数
    	Object(int sz); // 构造函数的声明;
    	Object(int sz, float pe); // 构造函数的声明;
    };
    Object::Object(int sz) // 构造函数的定义
    {
        
    	count = sz;
    	price = 0;
    }
    Object::Object(int sz, float pe)
    {
        
    	count = sz;
    	price = pe;
    }
    int main()
    {
        
    	int a = 10;
    	int b(10);
    	int c = int(10);
    
    	Object obj1; // 调用缺省构造函数
    	Object obj2(12);
    	Object obj3 = Object(12);
    	Object Obj4(12, 45.56);
    	Object obj5(); // 不可以构造对象;会给系统混乱，系统认为是函数的声明，
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]  
当我们进入主函数，给主函数分配栈帧空间，然后系统先给tea分配了一个栈帧空间，此时并没有对象，只给名字，这个空间中没有构建对象，再往下走，给book分配空间，然后给car分配空间，**只是有空间没有构建对象!**  
编译器在编译的时候就知道这个CGoods多大,大小就是数据成员的大小，与C计算结构体大小的方法，对齐方法都一致，不要把函数计算在这个类型大小里面，因为对象只含有数据，不含方法。进入主函数时，系统就知道tea,book,car都是CGoods类型，相应地给他们分配空间，此时只有空间，没有对象。构造函数也是类的非静态或不是有源的的成员函数，必然有this指针，构建tea的对象，tea的对象给this指针，在tea的空间中对tea进行构建，初始化，当在book调用，把book地址传递过去 ，构造函数在book地址创建对象并初始化。  
构造函数的三个任务：1.创建对象2.在位置空间进行初始化

以列表方式初始化成员变量或成员对象

class Object
    {
        
    private:
    	int count;
    	float price;
    public:
    	Object():count(0),price(0) {
        } // 缺省构造函数
    	Object(int sz); // 构造函数的声明;
    	Object(int sz, float pe); // 构造函数的声明;
    };
    // 构造函数的定义
    Object::Object(int sz) :count(sz),price(0)
    {
        
    	//count = sz;
    	// price = 0;
    }
    Object::Object(int sz, float pe):count(sz),price(pe)
    {
        
    	// count = sz;
    	//price = pe;
    }

任何一个类只有一个缺省构造函数，不能造成冲突

class CGoods
    {
        
    private:
    	char Name[21];
    	int Amount;
    	float Price;
    	float Total_value;
    public:
    	//缺省的构造函数
    	// CGoods(CGoods * const this)
    	CGoods()
    	{
        
    		this->Name[0] = '\0';
    		this->Price = 0.0;
    		this->Amount = 0;
    		this->Total_value = 0.0;
    	}
    	//两个参数的构造函数,货名和单价
    	// CGoods(CGoods * const this,char *name,float price)
    	CGoods(char* name, float price)
    	{
        
    		strcpy(this->Name, name);
    		this->Price = price;
    		this->Amount = 0;
    		this->Total_value = 0.0;
    	}
    	//三个参数的构造函数，货名，个数和单价
    	// CGoods(CGoods * const this,char* name, int amount, float price)
    	CGoods(char* name, int amount, float price)
    	{
        
    		strcpy(this->Name, name);
    		this->Amount = amount;
    		this->Price = price;
    		this->Total_value = price * amount;
    	}
    };
    int main()
    {
        
    	CGoods Car1("夏利 2000", 30,98000.0);
    	//CGoods(&Car1,"夏利 2000", 30,98000.0);
    	CGoods Car2 = CGoods("夏利 2000", 30,98000.0);
    
    	CGoods Car3("桑塔那 2000",164000.0);
    	//CGoods(&Car3,"桑塔那 2000",164000.0);
    	return 0;
    }

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

## 析构函数的定义 ##

当定义一个对象时，C++自动调用构造函数建立该对象并进行初始化，那么当一个对象的生命周期结束时，C++也会自动调用一个函数注销该对象并进行善后工作，这个特殊的成员函数即析构函数（destructor）：

1.  构函数名与类名相同，但在前面加上字符‘~’，如 ： ~CGoods（）。
2.  析构函数无函数返回类型，与构造函数在这方面是一样的。但析构函数不带任何参数。生不带来，死不带去。  
    3.一个类有一个也只有一个析构函数，这与构造函数不同。  
    4.对象注销时，系统自动调用析构函数。只是释放对象占用的资源，空间是系统消耗的。
3.  如果类说明中没有给出析构函数，则 C++编译器自动给出一个缺省的析构函数。如： ~类名（） \{\}  
    ![在这里插入图片描述][20201220222423871.png_pic_center]  
    这两种方法等价  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]  
    ***动态创建类的对象，所谓动态指在程序运行时建立对象。***

class Object
    {
        
    private:
    	int value;
    public:
    	Object(int sz):value(sz)
    	{
        
    		cout<<"Create Object: "<<this<<"\t"<<value<<endl;
    	}
    	~Object()
    	{
        
    		cout<<"Destroy Object: "<<this<<endl;
    	}
    	int GetValue() const {
         return value;}
    };
    int main()
    {
        
    	Object *p = new Object(10);//申请空间 调用构造函数
    	int x = p->GetValue();
    	x = (*p).GetValue();
    
    	delete p;//析构函数再释放空间
    	p = NULL;
    	p = new Object[10]; // ?
    
    	delete []p;
    	return 0;
    }

int main()
    {
        
    	// 1 创建空间， 2 调用构造函数创建对象;
    	Object *p = new Object(10);
    
    	// 只是申请空间。
    	Object *s = (Object*)::operator new(sizeof(Object));
    
    	//Object *s = (Object*) malloc(sizeof(Object));
    	// 定位 new //
    	new(s) Object(100);
    
    	s->~Object();
    	::operator delete(s);
    	s = NULL;
    	return 0;
    }

![在这里插入图片描述][20201220224018547.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]  
构造只能调用一次。自己不能决定生，但是可以决定死。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]  
全局变量先  
打印 1 3 （进入主函数之前，已经构建1,3） 进入主函数，2，要结束了，析构2，回到主函数，要析构全局了。  
![在这里插入图片描述][20201220224555495.png_pic_center]  
局部变量区 就是栈区，依次入栈，先进后出，先进 2 4 5，出就是 5 4 2  
创建顺序 2 4 5，析构顺序 5 4 2

## 在主函数之前运行一个函数 ##

定义一个类，在构造函数调用外部函数，定义一个全局对象，在进入主函数之前，调用全局对象的构造函数，构造函数调用其他函数，函数就先于主函数运行。

## 在主函数运行完毕之后，其他函数被调用 ##

主函数要结束，全局对象要撤销，调用析构函数。

**C语言也可以完成在主函数之前运行一个函数**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/cd5a0d716e4946738437a83bcc418450.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/890b008303eb43dfa9ad9e65c82c0745.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201220204537392.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/20201220210216404.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/20201220210301275.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[20201220213127678.png_pic_center]: https://img-blog.csdnimg.cn/20201220213127678.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201220214718540.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/20201220215343483.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/20201220222111820.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[20201220222423871.png_pic_center]: https://img-blog.csdnimg.cn/20201220222423871.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/2020122022252282.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[20201220224018547.png_pic_center]: https://img-blog.csdnimg.cn/20201220224018547.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]: https://img-blog.csdnimg.cn/20201220224033595.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 10]: https://img-blog.csdnimg.cn/20201220224332458.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY=,size_16,color_FFFFFF,t_70#pic_center
[20201220224555495.png_pic_center]: https://img-blog.csdnimg.cn/20201220224555495.png#pic_center