【C++从青铜到王者】第三篇:C++类和对象(中篇)

短命女 2022-10-17 04:24 112阅读 0赞

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

# 系列文章目录 #

--------------------

### 文章目录 ###

*  系列文章目录
 *  前言
 *  一、类的6个默认成员函数
 *  二、构造函数
 *   *   *  1.构造函数概念
         *  2.构造函数特性
 *  三、析构函数
 *   *   *  1.析构函数概念
         *  2.析构函数特性
 *  四、拷贝构造函数
 *   *   *  1.拷贝构造函数概念
         *  2.拷贝构造函数特征
 *  五、运算符重载
 *   *   *  1.运算符重载概念
         *  2.运算符重载特性
 *  六、const成员函数
 *   *   *  1.const修饰类的成员函数
         *  2.const修饰类的对象和成员函数
 *  七、取地址及const取地址操作符重载
 *  总结

--------------------

# 前言 #

--------------------

![在这里插入图片描述][20210601183031214.png_pic_left]

# 一、类的6个默认成员函数 #

如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面 6个默认成员函数 。

> class Date \{\};

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70_pic_center 1]  
 默认成员函数：就是用户没有显示实现该成员函数，编译器会替用户实现一份，没有显示定义就是没有自己实现。

# 二、构造函数 #

### 1.构造函数概念 ###

对于Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？  
代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    class Date
    { 
    public:
    	void SetDate(int year, int month, int day)  //初始化参数
    	{  
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	void Display()
    	{ 
    		std::cout << _year << ":" << _month << ":" << _day << std::endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    { 
    	Date d1;
    	d1.SetDate(2021, 5, 28);
    	d1.Display();
    	Date d2;
    	d2.SetDate(2021, 5, 29);
    	d2.Display();
    	return 0;
    }

构造函数:是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

### 2.构造函数特性 ###

构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。  
其特征如下：

1.  函数名与类名相同。
2.  无返回值。
3.  对象实例化时编译器自动调用对应的构造函数。
4.  构造函数可以重载。

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

代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    class Date
    { 
    public:
    	Date()                              //无参构造函数
    	{ 
    
    	}
    	Date(int year, int month, int day) //带参构造函数
    	{ 
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	void Display()
    	{ 
    		std::cout << _year << ":" << _month << ":" << _day << std::endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    { 
    	Date d1;               //调用无参构造函数
    	d1.Display();
    	Date d2(2021, 5, 30);  //调用带参构造函数
    	d2.Display();
    	Date d3();            //此时并没有调用构造函数，对象并没有实例化出来，不知道是函数的声明,还是构造函数。
    	return 0;
    }

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

1.  如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

代码如下：

class Date
    { 
    public:
    	/* // 如果用户显式定义了构造函数，编译器将不再生成 Date (int year, int month, int day) { _year = year; _month = month; _day = day; } */
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    void Test()
    { 
    	// 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
    	Date d;
    }

1.  无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数，所以下面代码编译不成功。

代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    class Date
    { 
    public:
    	Date()                                             //1.无参构造函数
    	{ 
    		_year = 1000;
    		_month = 1;
    		_day = 1;
    	}
    	Date(int year = 1000, int month = 1, int day = 1)  //2.全缺省构造函数
    	{ 
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    { 
    	Date d1; //对象实例化时自动调用构造函数，所以这里不能调用两个构造函数。
    	return 0;
    }

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

1.  关于编译器生成的默认成员函数，很多童鞋会有疑惑：在我们不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象year/month/\_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么卵用？？  
    解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如int/char…；自定义类型就是我们使用自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员\_t调用的它的默认成员函数,自定义类型-》class/struct/union。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 2]

代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    class Time
    { 
    public:
    	Time()
    	{ 
    		std::cout << "Time()" << std::endl;
    		_hour = 0;
    		_minute = 0;
    		_second = 0;
    	}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    class Date
    { 
    public:
    	void print()
    	{ 
    		std::cout << _year << ":" << _month << ":" << _day << std::endl;
    	}
    private:
    	//类置内型不初始化
    	int _year;
    	int _month;
    	int _day;
    
    	//自定义类型初始化
    	Time _t;
    };
    int main()
    { 
    	Date d;
    	d.print();
    	return 0;
    }

# 三、析构函数 #

### 1.析构函数概念 ###

前面通过构造函数的学习，我们知道一个对象时怎么来的，那一个对象又是怎么没呢的？  
析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

### 2.析构函数特性 ###

析构函数是特殊的成员函数。  
其**特征**如下：

1.  析构函数名是在类名前加上字符 ~。
2.  无参数无返回值。
3.  一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4.  对象生命周期结束时，C++编译系统系统自动调用析构函数。
5.  先构造的后析构，后构造的先析构  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 3]

代码如下：

#include<iostream>
    #include<assert.h>
    typedef int DataType;
    class SeqList
    { 
    public:
    	SeqList(int capacity = 10)
    	{ 
    		_pData = (DataType*)malloc(sizeof(DataType)*capacity);
    		assert(_pData);
    		_size = 0;
    		_capacity = capacity;
    	}
    	~SeqList()                 //析构函数完成对类的资源清理
    	{ 
    		free(_pData);
    		_pData = NULL;
    		_size = _capacity = 0;
    	}
    private:
    	DataType* _pData;
    	int _size;
    	int _capacity;
    };

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 4]

# 四、拷贝构造函数 #

### 1.拷贝构造函数概念 ###

在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 5]  
那在创建对象时，可否创建一个与一个对象一某一样的新对象呢？  
**拷贝构造函数**： 只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。  
代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    class Date
    { 
    public:
    	Date(int year = 2021, int month = 5, int day = 31)  //构造函数
    	{ 
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	Date(const Date& d2)
    	{ 
    		_year = d2._year;
    		_month = d2._month;
    		_day = d2._day;
    	}
    	void Display()
    	{ 
    		std::cout << _year << ":" << _month << ":" << _day << std::endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    { 
    	Date d1;
    	d1.Display();
    	Date d2(d1);  //把d1拷贝给d2
    	d2.Display();
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 6]

### 2.拷贝构造函数特征 ###

拷贝构造函数也是特殊的成员函数，其特征如下：

1.  拷贝构造函数是构造函数的一个重载形式。
2.  拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 7]
3.  若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 8]

代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    class Date
    { 
    public:
    	Date(int year = 2021, int month = 06, int day = 01)
    	{ 
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	void Display()
    	{ 
    		std::cout << _year << ":" << _month << ":" << _day << std::endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    { 
    	Date d1;
    	d1.Display();
    	Date d2(d1);  //调用默认拷贝构造函数
    	d2.Display();
    	return 0;
    }

1.  那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的。**那么下面的类呢？验证一下试试？**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 9]  
    **因为调用析构函数时候,调用的浅拷贝，拷贝出来的两个指针指向同一个地址，然后析构时这块空间被释放了两次，第二次free时候对一个已经为空的空间进行释放会发生崩溃，对一个对象插入、删除数据都会导致另一个对象的改变。**

代码如下：

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
    class String
    { 
    public:
    	String(const char* str = "jack")
    	{ 
    		_str = (char*)malloc(strlen(str) + 1);
    		strcpy(_str, str);
    	}
    	~String()
    	{ 
    		std::cout << "~String()" << std::endl;
    		free(_str);
    	}
    private:
    	char* _str;
    };
    int main()
    { 
    	String s1("hello");
    	String s2(s1);
    }

# 五、运算符重载 #

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

### 1.运算符重载概念 ###

**C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数**，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。  
函数名字为：关键字operator后面接需要重载的运算符符号。函数原型：返回值类型 operator操作符(参数列表)。

### 2.运算符重载特性 ###

**注意：**

1.  不能通过连接其他符号来创建新的操作符：比如operator@。
2.  重载操作符必须有一个类类型或者枚举类型的操作数。
3.  用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义。
4.  作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的  
    操作符有一个默认的形参this，限定为第一个形参。
5.  **.\* 、:: 、sizeof 、?: 、.** 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

**比较运算符在成员函数中重载**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 10]

代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    class Date
    { 
    public:
    	Date(int year = 2021, int month = 6, int day = 1)
    	{ 
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	bool operator==(const Date& d2)  //==运算符重载
    	{ 
    		return _year == d2._year&&_month == d2._month&&_day == d2._day;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    { 
    	Date d1(2021,6,1);
    	Date d2(2021,6,1);
    	std::cout << (d1 == d2) << std::endl;
    	return 0;
    }

**赋值运算符重载**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 11]  
代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    class Date
    { 
    public:
    	Date(int year = 2021, int month = 6, int day = 1) //构造函数
    	{ 
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	Date(const Date& d2)                             //拷贝构造函数
    	{ 
    		_year = d2._year;
    		_month = d2._month;
    		_day = d2._day;
    	}
    	Date& operator = (const Date& d2)               //赋值运算符重载
    	{ 
    		if (this != &d2)
    		{ 
    			_year = d2._year;
    			_month = d2._month;
    			_day = d2._day;
    		}
    		return *this;
    	}
    	void Display()
    	{ 
    		std::cout << _year << ";" << _month << ":" << _day << std::endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    { 
    	Date d1;
    	d1.Display();
    	Date d2(2021,5,31);
    	d2.Display();
    	d1 = d2;
    	d2.Display();
    	d1.Display();
    }

**赋值运算符主要有五点：**

1.  参数类型
2.  返回值
3.   检测是否自己给自己赋值
4.  返回\*this
5.  一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 12]

代码如下：

class Date
    { 
    public:
    	Date(int year = 1900, int month = 1, int day = 1)
    	{ 
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    { 
    	Date d1;
    	Date d2(2018，10， 1);
    	// 这里d1调用的编译器生成operator=完成拷贝，d2和d1的值也是一样的。
    	d1 = d2；
    	return 0;
    }

那么编译器生成的默认赋值重载函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？  
**这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。**  
代码如下：

class String
    { 
    public:
    	String(const char* str = "")
    	{ 
    		_str = (char*)malloc(strlen(str) + 1);
    		strcpy(_str, str);
    	}
    	~String()
    	{ 
    		cout << "~String()" << endl;
    		free(_str);
    	}
    private:
    	char* _str;
    };
    int main()
    { 
    	String s1("hello");
    	String s2("world");
    	s1 = s2;
    }

**区分下面代码**：

Date d1(2021, 6, 1);
    Date d2(d1);
    Date d3 = d1;

Date d1(2021, 6, 1)调用的是**构造函数**; Date d2(d1)调用的是**拷贝构造函数**。Date d3 = d1;注意：不是是赋值运算符重载函数，第三句代码也是**拷贝构造函数。**

**拷贝构造函数和赋值运算符重载函数的使用场景：**  
 **拷贝构造**：拷贝构造是使用一个同类对象去构造初始化另一个创建的对象。  
 **赋值运算符重载**：赋值重载主要是在两个对象都已经存在的情况下，把一个对象赋值给另一个对象。

# 六、const成员函数 #

### 1.const修饰类的成员函数 ###

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 13]  
代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    class Date
    { 
    public:
    	void Display()
    	{ 
    		cout << "Display ()" << endl;
    		cout << "year:" << _year << endl;
    		cout << "month:" << _month << endl;
    		cout << "day:" << _day << endl << endl;
    	}
    	void Display() const
    	{ 
    		cout << "Display () const" << endl;
    		cout << "year:" << _year << endl;
    		cout << "month:" << _month << endl;
    		cout << "day:" << _day << endl << endl;
    	}
    private:
    	int _year; // 年
    	int _month; // 月
    	int _day; // 日
    };
    int main()
    { 
    	Date d1;
    	d1.Display();
    	const Date d2;
    	d2.Display();
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 14]

### 2.const修饰类的对象和成员函数 ###

请思考下面的几个问题：

1.  const对象可以调用非const成员函数吗？  
    **不可以**，因为const修饰的对象为只读类型，若调用非const非成员函数,属于权限放大行为，只读权限变成既可以只读又可以可写。
2.  非const对象可以调用const成员函数吗？  
    **可以**，因为非const对象权限拥有可读、可写权限，调用const成员函数属于权限缩小问题，权限变为只读。
3.  const成员函数内可以调用其它的非const成员函数吗？  
    **不可以**，因为const修饰的成员函数为只读类型，若调用非const非成员函数,属于权限放大行为，只读权限变成既可以只读又可以可写。
4.  非const成员函数内可以调用其它的const成员函数吗？  
    **可以**，因为非const成员函数权限拥有可读、可写权限，调用const成员函数属于权限缩小问题，权限变为只读。

**还是那句话，权限只可以缩小，不能够放大。也就是我本身只能是可读的(const)，不能传过去编程可读可写的了(非const)**

# 七、取地址及const取地址操作符重载 #

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。  
代码如下：

#include<iostream>
    using namespace std;
    class Date
    { 
    public:
    	Date* operator&()
    	{ 
    		return this;
    	}
    	const Date* operator&()const
    	{ 
    		return this;
    	}
    private:
    	int _year; // 年
    	int _month; // 月
    	int _day; // 日
    };

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，**比如想让别人获取到指定的内容**！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 15]

--------------------

# 总结 #

以上就是今天要讲的内容，本文仅仅简单介绍了类和对象6个默认成员函数的使用，而默认成员函数提供了大量能使我们快速便捷地处理数据的方法，我们一定要掌握。另外如果上述有任何问题，请懂哥指教，不过没关系，主要是自己能坚持，更希望有一起学习的同学可以帮我指正，但是如果可以请温柔一点跟我讲，爱与和平是永远的主题，爱各位了。  
![在这里插入图片描述][20210602163056324.png_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221014/69f749a36bbc48f89c13bb8bbd44d1f2.png
[20210601183031214.png_pic_left]: /images/20221014/6ebbcc254ed549d48b485ee24f1059ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221014/eed000a6e4da43e2a6c5bdeb6f1131cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70]: /images/20221014/d85b88438e394df78b9ba021d81e6be7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 1]: /images/20221014/19099038b3e04426bcf68aff88a0e642.png
[20210601185437250.png]: /images/20221014/3a71a6f8d4bb48738d4fa8b1369e1556.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 2]: /images/20221014/fe990e2c53bd4ac58ba4fee4eb4414e9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 3]: /images/20221014/1f347bdd4d4c4c9d8e9208d8e3dcc165.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 4]: /images/20221014/d4edd98882e14da2bef0934a7dec7c94.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 5]: /images/20221014/884b3496bac042c8ae52164ceedad536.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 6]: /images/20221014/9133022d2d424089babab51c27859415.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 7]: /images/20221014/a7bcc679adae4e8695618a4a31182e67.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 8]: /images/20221014/d13fe42b54834987aa18ad007a410dcf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 9]: /images/20221014/7f66eb114c61420598bfca46b197a8c8.png
[20210602163213951.png]: /images/20221014/0ff542b3d90748618ba370c8ae3880ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 10]: /images/20221014/1d2df059f21c4f5295b5730b7000311b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 11]: /images/20221014/cc0763ee5bea44adb2a0244cc946379d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 12]: /images/20221014/35190e664fc4437e8bd0b563b3bd34c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 13]: /images/20221014/2d92df572d604effba4272a050c3e320.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 14]: /images/20221014/1e30b53fbfc0488db2539a85ffcff798.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 15]: /images/20221014/92136610435b499a93f769cececb869b.png
[20210602163056324.png_pic_center]: /images/20221014/248cfdd78172428597739b21ab4dbd95.png