C++的基础使用：C++语言的新特性及面向对象

你的名字 2022-08-29 10:12 192阅读 0赞

## C++的基础使用：C++语言的新特性及面向对象 ##

在本章 C++基础里，这里主要介绍概念为主，主要介绍 C++与 C 语言中常用的不同点，和一些新的变化。其中不会去说指针、数据类型、变量类型、判断和循环等这些知识，这些和C 语言基本是一样使用的。我们主要学习 C++的面向对象编程，对学习 Qt 有很大的帮助；  
Qt 里就能体现到 C++编程带来的优势和便处。就算没学过 C++，学习 Qt 也不会很难。写 C++基础这章，编者已经把重要概念写出来，但是实际上 C++的内容不止这么多，第本章是快餐式 C++入门，主要是为了更好的理解 Qt 中的 C++语法，学习 Qt时也方便理解其中的内容。

**1.C++语言的新特性：**

C++比 C 语言新增的数据类型是布尔类型（bool）。但是在新的 C 语言标准里已经有布尔类型了，但是在旧的 C 语言标准里是没有布尔类型的，编译器也无法解释布尔类型。

在传统的 C 语言里，变量初始化时必须在程序的前面定义在前面，而 C++则是可以随用随定义。C++也可以直接初始化，比如 int x(100);这样就直接赋值 x=100，这些都是 C++特性的好处。这里只说这些常用的新特性，其他特性不做描述或者解释了。

**1.1:C++的输入输出方式：**

在C语言中，我们的输入输出方式为:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70]  
在C++中我们使用cin和cout来进行替换：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 1]  
在效率上，C语言的效率高，但没有C++的方便；

cout语法形式：

cout<<x<<endl;

其中x为任意类型，endl为换行符；且变量之间不可用逗号隔开；  
cin的语法形式：

cin>>x;

**1.2.C++的命名空间：namespace：**

如下面的模板代码：

#include<iostream>
    using namespace std;
    int main()
    {
        
    	cout<<"hello,word"<<endl;
    	return 0;
    }

关于头文件，有.h的是非标准的输入输出流，C的标准库，有.h的是标准的输入输出流，要使用命名空间；  
using 是编译指令，声明当前命名空间的关键词。cin 和 cout 可以写 std::cin 和 std::cout，“::”表示作用域，cin 和 cout 是属于 std 命名空间下的东西，这里可以理解成 std 的 cin 和 std 的 cout。

问题1:为什么要使用命名空间：

有的名字容易重复，使用命名空间的形式来加以区分，具体来说就是加个前缀，  
就比如：  
C++当中有一个vector容器，你自己在写一个vector类就冲突了，于是标准库前面加上std::,你自己的类也可以加一个自定义前缀，但是这样写起来繁琐，于是写一个：using namespace std；，那么接下来直接写vector即可；

我们可以通过代码来举一个例子：

#include<iostream>
    using namespace std;
    namespace A
    {
        
    	int x=1;
    	void fun()
    	{
        
    		cout << "A namespace"<<endl;
    	}
    }
    using namespace A;
    
    int main()
    {
        
    	fun();  //已声明命名空间，减少繁琐
    	A::x = 3;
    	cout<<A::x<<endl;
    	A::fun();
    	return 0;
    }

**2.C++的面向对象：**

面向对象的三大特征是继承，多态和封装，C++重面向对象重要的就是这些，我们下面通过一些简单的实例加以理解，从这小节开始，我们将开启新的编程旅途。与 C 语言编程的思想完全不同了，这就是 C++理解概念和掌握这些编程方法对学习 C++有很大的好处。

**2.1:类和对象：**  
C++在C语言的基础上增加了面向对象，类中的数据和方法被称作类的成员；  
比如：狗为类，而旺财就被称为对象；  
从类中实例化对象有两种方法：从栈中实例化对象；从堆中实例化对象；  
参考代码如下：

#include<iostream>
    #include<string>
    using namespace std;
    class Dog
    {
        
    public:
    	string name;
    	int age;
    	void run()
    	{
        
    		cout << "小狗的名字是："<<name <<"年龄是："<<age<<endl;
    	}
    };
    int main()
    {
        
    	Dog dog1;
    	dog1.name="旺财";
    	dog1.age=1000;
    	dog1.run();
    
    	Dog *dog2= new Dog();
    	if(NULL==dog2)
    	{
        return 0;}
    	dog2->name = "富贵";
    	dog2->age = 20000;
    	dog2->run();
    	delete dog2;
    	dog2 = NULL;
    	return 0;
    }

目前，我们只需要掌握这个步骤，明白定义和使用即可；

**2.2.构造函数和析构函数：**

什么是构造函数？构造函数在对象实例化时被系统自动调用，仅且调用一次。构造函数出现在哪里？前面我们学过类，实际上定义类时，如果没有定义构造函数和析构函数，编译器就会生成一个构造函数和析构函数，只是这个构造和析构函数什么事情也不做，所以我们不会注意到一点。  
构造函数的特点如下：  
（1） 构造函数必须与类名同名；  
（2） 可以重载，（重载？新概念，后面学到什么是重载。）；  
（3） 没有返回类型，即使是 void 也不行。

什么是析构函数？与构造函数相反，在对象结束其生命周期时系统自动执行析构函数。实际上定义类时，编译器会生成一个析构函数。  
析构函数的特点如下：  
（1） 析构函数的格式为~类名()；  
（2） 调用时释放内存（资源）；  
（3） ~类名()不能加参数；  
（4） 没有返回值，即使是 void 也不行。

下面我们通过简单的例子来说明构造函数和析构函数的使用。

#include<iostream>
    #include<string>
    using namespace std;
    
    class Dog
    {
        
    public:
    	Dog();
    	~Dog();
    };
    int main()
    {
        
    	Dog dog;
    	cout << "构造和析构函数实例"<<endl;
    	return 0;
    }
    //类的函数可以在类里实现也可以在类外实现；但需要加上作用域符号；
    Dog::Dog()
    {
        
    	cout <<"构造函数执行"<<endl;
    }
    Dog::~Dog()
    {
        
    	cout<<"析构函数执行"<<endl;
    }

**2.3:this指针：**

一个类中的不同对象在调用自己的成员函数时，其实它们调用的是同一段函数代码，那么成员函数如何知道要访问哪个对象的数据成员呢？  
没错，就是通过 this 指针。每个对象都拥有一个 this 指针，this 指针记录对象的内存地址。在 C++中，this 指针是指向类自身数据的指针，简单的来说就是指向当前类的当前实例对象。

关于类的 this 指针有以下特点：  
（1） this 只能在成员函数中使用，全局函数、静态函数都不能使用 this。实际上，成员函数默认第一个参数为 T \* const this。也就是一个类里面的成员了函数 int func(int p)，func 的原型在编译器看来应该是 int func(T \* const this,int p)。  
（2） this 在成员函数的开始前构造，在成员函数的结束后清除。  
（3） this 指针会因编译器不同而有不同的放置位置。可能是栈，也可能是寄存器，甚至全局变量。

下面以简单的例子来说明 this 的用法。我们还是以狗类为例，按上面的 this 解释，this 只能够在成员函数使用，并可以指向自身数据。我们就可以写这样简单的例子来说明 this 的用法。  
我们在 Qt 里也会遇到 this 这个东西，下面这个例子就很容易解释 Qt 里的 this 指针的用法。

#include<iostream>
    #include<string>
    using namespace std;
    class Dog
    {
        
    public:
    	string name;
    	void func();
    };
    int main()
    {
        
    	Dog dog;
    	dog.func();
    	return 0;
    }
    void Dog::func()
    {
        
    	this->name="旺财";
    	cout<<"小狗的名字是："<<name<<endl;
    }

**2.4:继承的概念：**

面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。  
当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。在 Qt 里大量的使用了这种特性，当 Qt 里的类不满足自己的要求时，我们可以重写这个类，就是通过继承需要重写的类，来实现自己的类的功能。  
一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

class derived-class: access-specifier base-class

与类的访问修饰限定符一样，继承的方式也有几种。其中，访问修饰符 access-specifier 是public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。  
下面来捋一捋继承的方式，例子都是以公有成员和公有继承来说明，其他访问修饰符和其他继承方式，大家可以在教程外自己捋一捋。这个公有成员和继承方式也没有什么特别的，无非就是不同的访问权限而已，可以这样简单的理解。

1.  公有继承（public）：当一个类派生继承公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
2.  保护继承（protected）： 当一个类派生继承保护基类时，基类的公有和保护成员将成为派生类的保护成员。
3.  私有继承（private）：当一个类派生继承私有基类时，基类的公有和保护成员将成为派生类的私有成员。  
    下面我们还是以狗类为例，已经定义了 name，age 和 run()方法。  
    假设我们不想重写这个狗类，而是新建一个 Animal 类，让狗类去继承这个 Animal 类。  
    假设是公有继承，那么我们是不是可以在狗类实例的对象里去使用继承 Animal 类里的成员呢？  
    带着这个疑问，我们使用下面的例子来说明。

#include<iostream>
    #include<string>
    using namespace std;
    class Animal
    {
        
    	string color;
    	int weight;
    }
    class Dog : public Animal
    {
        
    public:
    	string name;
    	int age;
    	void fun();
    };
    int main()
    {
        
    	Dog dog;
    	dog.color="黑色";
    	dog.weight=222;
    	cout<<"狗的毛发颜色是："<<dog.color<<endl;
    	cout<<"狗的体重是："<<dog.weight<<endl;
    	return 0;
    }

**2.5.重载的概念：**

C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。  
重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。  
当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。

函数重载：

在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。我们不能仅通过返回类型的不同来重载函数。在 Qt源码里，运用了大量的函数重载，所以我们是有必要学习一下什么是函数重载。  
不仅在 C++，在其他语言的里，都能看见函数重载。因为需要不同，所以有重载各种各样的函数。

下面通过一个小实例来简单说明一下函数重载的用法。  
我们还是以狗类为说明，现在假设有个需求。我们需要打印狗的体重，分别以整数记录旺财的体重和小数记录旺财的体重，同时以整数打印和小数打印旺财的体重。那么我们可以通过函数重载的方法实现这个简单的功能。

#include<iostream>
    #include<string>
    using namespace std;
    class Dog
    {
        
    public:
    	string name;
    	void getWeight(int weight)
    	{
        
    		cout<<name<<"的体重是："<<weight<<"kG"<<endl;
    	}
    	void getWeight(double weight)
    	{
        
    		cout<<name<<"的体重是："<<weight<<"kG"<<endl;
    	}
    };
    int main()
    {
        
    	dog.name = "旺财";
    	dog.getWeight(10);
    	dog.getWeight(10.5);
    	return 0;
    }

通过上面的例子我们可以知道重载函数的使用方法，避免用户传入的参数类型，有可能用户传入的参数类型不在我们写的重载函数里，假若用户传入了一个字符串类型，这样编译器就会匹配不到相应的重载函数，编译时就会报错。其实我们还可以多写几个重载函数，设置多几种类型，如 string 类型，char 类型，float 类型等。

运算符重载：

运算符重载的实质就是函数重载或函数多态。运算符重载是一种形式的 C++多态。目的在于让人能够用同名的函数来完成不同的基本操作。

运算符函数形式：operatorp（argument-list），operator 后面的’p’为要重载的运算符符号。重载运算符的格式如下：

<返回类型说明符> operator <运算符符号>(<参数表>)
    {
        
     <函数体> 
     }

下面是可重载的运算符列表：  
![在这里插入图片描述][ffd81aaf44294adf95118b657f1734ed.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 2]  
不可重载的运算符：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 3]  
根据上表我们知道可以重载的运算符有很多，我们以重载“+”运算符为例，  
实际上用重载运算符我们在实际应用上用的比较少，我们只需要了解和学习这种思想即可。

下面的实例使用成员函数演示了运算符重载的概念。在这里，对象作为参数进行传递，对象的属性使用 this 运算符进行访问。  
下面还是以我们熟悉的狗类为例。声明加法运算符用于把两个Dog 对象相加的体重相加，返回最终的 Dog 对象然后得到第三个 Dog 对象的体重。

#include<iostream>
    #include<string>
    using namespace std;
    class Dog
    {
        
    public: 
    	int weight; 
    	Dog operator+(const Dog &d) {
        
    		Dog dog;
    		dog.weight = this->weight + d.weight;
    		return dog;
     	}
    };
    int main()
    {
        
    	Dog dog1;
    	Dog dog2;
    	Dog dog3;
    	dog1.weight = 10;
    	dog2.weight = 20;
    	dog3 = dog1 + dog2;
    	cout<<"第三只狗的体重是："<<dog3.weight<<endl;
    	return 0;
    }

**2.6.多态的概念：**

C++多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数；  
**形成多态必须具备三个条件：**

1.  必须存在继承关系；
2.  继承关系必须有同名虚函数（其中虚函数是在基类中使用关键字 virtual 声明的函数，在派  
    生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数）；
3.  存在基类类型的指针或者引用，通过该指针或引用调用虚函数。  
    这里我们还需要理解两个概念：  
    **虚函数：**  
    是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。虚函数声明：

virtual ReturnType FunctionName(Parameter)

虚函数必须实现，如果不实现，编译器将报错

**纯虚函数：**  
若在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。  
纯虚函数声明如下：

virtual void funtion1()=0;

纯虚函数一定没有定义，纯虚函数用来规范派生类的行为，即接口。

包含纯虚函数的类是抽象类，抽象类不能定义实例，但可以声明指向实现该抽象类的具体类的指针或引用。

上面那些概念大家可以捋一捋，毕竟 C++概念还是挺多的。为什么说到多态要与虚函数和纯虚函数扯上关系？  
光说概念没有实例确实难理解。下面我们还是以我们熟悉的狗类和动物类，另外加一个猫类进行多态的讲解。

#include<iostream>
    #include<string>
    using namespace std;
    //定义一个动物类
    class animal
    {
        
    public:
    	virtual void run()
    	{
        
    		cout<<"Animal 的 run()方法"<<endl;
    	}
    };
    //定义一个狗类
    class Dog : public Animal
    {
        
    public:
    	void run() 
    	{
        
    		cout<<"Dog 的 run()方法"<<endl;
    	}
    };
    //定义一个猫类。并继承动物类
    class Cat : public Animal
    {
        
    public:
    	void run() 
    	{
        
    		cout<<"cat 的 run()方法"<<endl;
    	}
    };
    int main()
    {
        
    	//声明一个动物的指针对象，并没有实例化
    	Animal *animal;
    	Dog dog;
    	Cat cat;
    	animal = &dog;
    	animal->run();
    	animal = &cat;
    	animal->run();
    	return 0;
    }

通过如上，我们发现：虚函数是C++实现多态的机制，核心理念就是通过基类访问派生类的函数；

前提是基类的 run()方法必须声明为虚函数，如果不声明为虚函数，基类的指针将访问到基类自己的 run()方法。我们可以尝试把 virtual 关键字去掉再重新编译测试，如果不加关键字 virtual 会是什么情况。

可以理解是 animal 指针实例化的过程。当基类的 run()方法定义成虚函数，编译器不静态链接到该函数，它将链接到派生类的 run()方法，进行实例化。

**2.7.数据封装：**

封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用，从而确保了安全。数据封装引申出了另一个重要的 OOP 概念，即 数据隐藏。

数据封装是一种把数据和操作数据的函数捆绑在一起的机制， 数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制，C++ 通过创建类来支持封装和数据隐藏（public、protected、private）。

在 C++程序中，任何带有公有和私有成员的类都可以作为数据封装和数据抽象的实例。通常情况下，我们都会设置类成员状态为私有（private），除非我们真的需要将其暴露，这样才能保证良好的封装性。这通常应用于数据成员，但它同样适用于所有成员，包括虚函数。

以狗类为例，增加一个食物的方法 addFood(int number)。将获得食物的方法设定在 public 下，这样 addFood(int number)方法就暴露出来了，也就是对外的接口。然后我们设置狗类的私有成员(private)食物的份数 total。我们在这个教程里第一次使用 private，在这章节里我们也可以学到什么时候该使用 private 什么时候使用 public。total 为获得的食物总数，然后我们还写一个公开的方法 getFood()在 public 下，通过 getFood()来打印出小狗总共获得了几份食物。

#include<iostream>
    #include<string>
    using namespace std;
    class Dog
    {
        
    public:
    	string name;
    	Dog(int i = 0)
    	{
        
    		total = i;//一般是在构造函数里初始化。不要在类内直接赋值初始化，有可能有些编译器不支持。
    	}
    	void addFood(int number) 
    	{
        
    		total = total + number; //将获得的食物份数赋值给 total。
    	}
    	int getFood() 
    	{
        
    		return total; //将返回食物的总份数,通过调用这个方法，即可访问私有成员的 total 总数。
    	}
    private:
    	int total;
    };
    int main()
    {
        
    	Dog dog;
    	dog.name = "旺财";
    	dog.addFood(3);
    	dog.addFood(2);
    	cout<<dog.name<<"总共获得了"<<dog.getFood()<<"份食物"<<endl;
    	return 0;
    }

私有变量无法作为接口被main函数调用，但可以被成员函数进行调用；

**2.8.数据抽象：**

数据抽象是指，只向外界提供关键信息，并隐藏其后台的实现细节，即只表现必要的信息而不呈现细节。数据抽象是一种依赖于接口和实现分离的编程（设计）技术。

数据抽象的好处：

1.  类的内部受到保护，不会因无意的用户级错误导致对象状态受损。
2.  类实现可能随着时间的推移而发生变化，以便应对不断变化的需求，或者应对那些要  
    求不改变用户级代码的错误报告。

举个简单的例子，比如我们生活中的手机。手机可以拍照、听音乐、收音等等。这些都是手机上的功能，用户可以直接使用。但是拍照的功能是如何实现的，是怎么通过摄像头取像然后怎么在屏幕上显示的过程，作为用户是不需要知道的。也就是暴露的不用太彻底，用户也不必须知道这种功能是如何实现的，只需要知道如何拍照即可。

就 C++ 编程而言，C++ 类为数据抽象提供了可能。它们向外界提供了大量用于操作对象数据的公共方法，也就是说，外界实际上并不清楚类的内部实现。  
其实像 cout 这个对象就是一个公共的接口，我们不必要知道 cout 是如何在屏幕上显示内容的。cout 已经在底层实现好了。

数据封装是一种把数据和操作数据的函数捆绑在一起的机制，而 数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制。  
**C++ 程序中，任何带有公有和私有成员的类都可以作为数据抽象的实例。**

**2.9.接口(抽象类)：**

接口描述了类的行为和功能，而不需要完成类的特定实现。C++ 接口是使用抽象类来实现的，抽象类与数据抽象互不混淆，数据抽象是一个把实现细节与相关的数据分离开的概念。 如果类中至少有一个函数被声明为纯虚 函数，则这个类就是抽象类。纯虚函数是通过在声明中使用 “= 0” 来指定的。

设计抽象类（通常称为 ABC）的目的，是为了给其他类提供一个可以继承的适当的基类。抽象类不能被用于实例化对象，它只能 作为接口使用。如果试图实例化一个抽象类的对象，会导致编译错误。

因此，如果一个 ABC 的子类需要被实例化，则必须实现每个虚函数，这也意味着 C++ 支持使用 ABC 声明接口。如果没有在派生类中重写纯虚函数，就尝试实例化该类的对象，会导致编译错误。可用于实例化对象的类被称为具体类。

根据概念我们来写个实例来说明抽象类。  
Aninmal 类的 run()方法定义为纯虚函数，纯虚函数不用实现，由派生类 Dog 和 Cat 类实现重写即可；

#include<iostream>
    #include<string>
    using namespace std;
    //定义一个动物类
    class animal
    {
        
    public:
    	virtual void run() = 0;
    };
    //定义一个狗类
    class Dog : public Animal
    {
        
    public:
    	void run() 
    	{
        
    		cout<<"Dog 的 run()方法"<<endl;
    	}
    };
    //定义一个猫类。并继承动物类
    class Cat : public Animal
    {
        
    public:
    	void run() 
    	{
        
    		cout<<"cat 的 run()方法"<<endl;
    	}
    };
    int main()
    {
        
    	//声明一个动物的指针对象，并没有实例化
    	Animal *animal;
    	Dog dog;
    	Cat cat;
    	animal = &dog;
    	animal->run();
    	animal = &cat;
    	animal->run();
    	return 0;
    }

学 C++重要的是思想，当我们对这种思想有一种的了解后，不管是 Qt 或者其他 C++程序，我们都能快速学习和了解。  
C++的内容就到此结束了。在这个 C++基础中，我们的例子非常简单，也十分之易懂，重要的是理解概念，许多 C++的课程都是以 C++的功能甚至是很复杂的算法作讲解，内容复杂且多。只要我们理解好上面的 C++的基础，对学习 C++有很大的帮助，不要求对 C++有很深的理解，至少在我们后面学习 Qt 时已经大概了解 Qt 中的 C++语法。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70]: /images/20220829/f776b9cc08e1415ca34a99e8f425edfd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 1]: /images/20220829/9fd1ddc308b243318d29863d16f434e7.png
[ffd81aaf44294adf95118b657f1734ed.png]: /images/20220829/b5b001caa3d84ec5bd4bedf2cc85156f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 2]: /images/20220829/ea85ebda858346d790e14875c418d9f5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 3]: /images/20220829/84a510d9c0a148e3943674b9e9d083ad.png