类的成员函数、结构体、联合体、枚举类

你的名字 2023-02-26 06:20 19阅读 0赞

### 目录 ###

*   *  类的成员函数
     *   *  内联成员函数：
         *  构造函数
         *   *  构造函数的形式：
             *  默认构造函数
             *   *  隐含生成的默认构造函数
             *  委托构造函数
             *  拷贝构造函数
             *   *  隐含的复制构造函数
             *  浅层复制与深层复制
             *  拷贝赋值 copy assignment
             *  移动构造
             *  析构函数
             *  类的组合
             *   *  构造组合类对象时的初始化次序
     *  类的前向引用声明
     *  结构体
     *  联合体
     *  枚举类
     *   *  语法形式：
         *  枚举类的优势：
         *  枚举类举例

## 类的成员函数 ##

*  在类中说明函数原型；
 *  可以在类外给出函数体的实现，并在函数名前使用`类名`和`作用域限定符::`加以限定
 *  也可以直接在类中给出函数体，形成`内联成员函数`
 *  允许声明重载函数和带默认参数值的函数

### 内联成员函数： ###

*  为了提高运行时效率，对于较简单的函数，可以声明为内联形式
 *  内联函数中不要有复杂结构(如循环语句和switch语句)
 *  在类中声明内联成员函数的方式
    
     *  将函数体放在类的类体中
     *  在类外使用inline关键字

通过以上描述可以发现，类外定义的类成员函数既可以是内联函数(要使用关键字inline)，也可以普通的类成员函数

### 构造函数 ###

#### 构造函数的形式： ####

*  函数名与类名相同；
 *  不能定义返回值类型，不能有`return`语句；；
 *  可以有形式参数，也可以没有形式参数；
 *  可以是内联函数；
 *  可以重载；
 *  可以带默认参数值。

#### 默认构造函数 ####

*  调用时可以不需要实参的构造函数
    
     *  参数列表为空的构造函数
     *  全部参数都有默认值的构造函数
 *  下面两个都是默认构造函数，如在类中同时出现，将会产生编译错误：
    
        Clock();
        Clock(int newH=0; int newM=0; int newS=0);
    
    注意：默认构造函数并不完全等同于编译器为我们默认生成的构造函数，程序员可以自己设置默认构造函数
    
    ##### 隐含生成的默认构造函数 #####
    
    如果程序中为定义构造函数，编译器将在需要时自动生成一个默认构造函数
    
     *  参数列表为空，不为数据成员设置初始值
     *  如果类内定义了成员的初始值，则使用类内定义的初始值
     *  如果没有定义类内初始值，则以默认方式初始化
     *  注意：基本类型的数据默认初始化的值是不确定的。
    
    如果程序中已定义构造函数，默认情况下编译器就不再隐含生成构造函数。如果此时依然希望编译器生成默认构造函数，可以使用`default`
    
        class Clock{ 
        public:
            Clock() = default; // 指示编译器提供默认构造函数
            Clock(int newH, int newM, int newS);
        private:
            int hour,minute,second;    
        };

构造函数使用示例：

// 类定义
    class Clock{ 
    public:
        Clock(int newH,int newM,int newS);
        void set(int newH,int newM,int newS);
        void showTime();
    private:
        int hour,minute,second;
    };
    
    // 构造函数的实现
    Clock::Clock(int newH,int newM,int newS):
    hour(newH),minute(newM),second(newS){ 
        }
    // 其他成员函数的实现，注意作用域限定符::的使用
    void Clock::showTime(){ 
        cout << hour << ":" << minute << ":" << second;
    }
    
    void Clock::setTime(int newH, int newM, int newS) { 
       hour = newH;
       minute = newM;
       second = newS;
    }
    
    int main(){ 
        Clock c(8,0,0);  // 自动调用构造函数
        c.showTime();
        return 0;
    }

#### 委托构造函数 ####

委托构造函数使用该类的其他构造函数执行初始化过程，这样做可以避免代码重复，提高代码的一致性，易于维护代码。

之前是这么写的

Clock::Clock(int newH, int newM, int newS): hour(newH),minute(newM),  second(newS)  {          //构造函数
    }
    
    Clock::Clock(): hour(0),minute(0),second(0) {  } //默认构造函数

C++ 11增加了委托构造函数，就可以省事了，用法如下：

Clock::Clock(int newH, int newM, int newS):  hour(newH),minute(newM),  second(newS){ 
    }
    
    Clock::Clock():Clock(6,6,6){ } // 调用了本类的其他构造函数

#### 拷贝构造函数 ####

***注意，所有包含动态分配成员的类都要人为提供拷贝构造函数***

拷贝构造函数是一种特殊的构造函数，其形参为本类的对象引用。作用是用一个已存在的对象去初始化同类型的新对象。

class 类名 { 
    public :
    
        类名（形参）；//构造函数
    	类名（const 类名 &对象名）；//拷贝构造函数；必须用const修饰符来修饰的引用对象，表示传进来的对象是只读类型
    
        // ...
    }；
    
    类名::类（ const 类名 &对象名）//拷贝构造函数的实现
    
    {     函数体    }

##### 隐含的复制构造函数 #####

*  如果程序员没有为类声明`拷贝构造函数`，则编译器自己生成一个**隐含**的拷贝构造函数。
 *  这个构造函数执行的功能是：用作为初始值的对象的每个数据成员的值，初始化将要建立的对象的对应数据成员。**(浅拷贝)**

**如果不希望对象被拷贝构造**

*  C++98做法：将拷贝构造函数声明为private，并且不提供函数的实现。
 *  C++11做法：用`=delete`指示编译器不生成默认复制构造函数。

class Point {    //Point 类的定义
    
    public:
    
        Point(int xx=0, int yy=0) {  x = xx; y = yy; }    //构造函数，内联
        Point(const Point& p) = delete;  //指示编译器不生成默认复制构造函数 
    
    private:
        int x, y; //私有数据
    };

拷贝构造函数被调用的三种情况

*  定义一个对象时，以本类另一个对象作为初始值，发生拷贝构造；

// 什么样的具体操作会触发拷贝构造呢？
    MyClass obj1;
    
     // 在“新创建”对象时，用一个已经存在的对象去初始化一个新对象，会触发拷贝构造函数
     // 用等于号 = 很直观，用 (已经存在的对象也可以) 也可以
    MyClass obj2 = obj1;
    // 或者
    MyClass obj3(obj1);

*  如果**函数**的形参是类的对象，调用函数时，将使用实参对象初始化形参对象，发生拷贝构造；
    
     *  ***对于上面这一点做一个简要的思考***：当调用函数时，其实是在堆栈上开辟一块空间载入被调用函数，此时普通的值传递就是把实参的值拷贝一份给形参，在这里是同样的道理，只不过这里传递的值的类型是某一个对象而已。因此拷贝是必要的一步，实参对象将其成员值拷贝一份给形参。
 *  如果函数的返回值是类的对象，函数执行完成返回主调函数时，将使用return语句中的对象初始化一个临时无名对象，传递给主调函数，此时发生拷贝构造。
    
     *  这种情况也可以通过`移动构造`避免不必要的复制

#### 浅层复制与深层复制 ####

浅层复制

*  实现对象间数据元素的一一对应复制。

深层复制

*  当被复制的对象数据成员是指针类型时，不是复制该指针成员本身，而是将指针所指对象进行复制。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODY2NzM2_size_16_color_FFFFFF_t_70][] ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODY2NzM2_size_16_color_FFFFFF_t_70 1][]

**示例：对象的深层复制**

#include <iostream>
    #include <cassert>
    
    using namespace std;
    
    class Point {  //类的声明同前面
    };
    
    class ArrayOfPoints { 
    public:
    	ArrayOfPoints(const ArrayOfPoints& pointsArray); // 拷贝构造函数声明
    
    	Point& element(int index) { 
    		assert(index >= 0 && index < size);
    	return points[index];
    	}
    //其他成员同前面
    };
    
    ArrayOfPoints::ArrayOfPoints(const ArrayOfPoints& v) {   // 深层拷贝构造函数
    	size = v.size;
    	points = new Point[size];
    	for (int i = 0; i < size; i++)
    		points[i] = v.points[i];
    }
    
    int main() { 
    	int count;
    	cout << "Please enter the count of points: ";
    	cin >> count;
    	ArrayOfPoints pointsArray1(count); //创建对象数组
    	pointsArray1.element(0).move(5,10);
    	pointsArray1.element(1).move(15,20);
    	ArrayOfPoints pointsArray2(pointsArray1); //创建副本
    	cout << "Copy of pointsArray1:" << endl;
    	cout << "Point_0 of array2: " << pointsArray2.element(0).getX() << ", "
    		<< pointsArray2.element(0).getY() << endl;
    	cout << "Point_1 of array2: " << pointsArray2.element(1).getX() << ", "
    		<< pointsArray2.element(1).getY() << endl;
    	pointsArray1.element(0).move(25, 30);
    	pointsArray1.element(1).move(35, 40);
    	cout<<"After the moving of pointsArray1:"<<endl;
    	cout << "Point_0 of array2: " << pointsArray2.element(0).getX() << ", "
    	<< pointsArray2.element(0).getY() << endl;
    	cout << "Point_1 of array2: " << pointsArray2.element(1).getX() << ", "
    		<< pointsArray2.element(1).getY() << endl;
    	
        return 0;
    
    }
    
    程序的运行结果如下：
    
    Please enter the number of points:2
    Default Constructor called.
    Default Constructor called.
    Default Constructor called.
    Default Constructor called.
    Copy of pointsArray1:
    Point_0 of array2: 5, 10
    Point_1 of array2: 15, 20
    After the moving of pointsArray1:
    Point_0 of array2: 5, 10
    Point_1 of array2: 15, 20
    Deleting...
    Destructor called.
    Destructor called.
    Deleting...
    Destructor called.
    Destructor called.

#### 拷贝赋值 copy assignment ####

*  拷贝赋值，是针对两个已经存在的同类对象而言的，所以这里并不存在构造这一说法。
 *  拷贝赋值会涉及到 `=` 运算符 重载

// 注意，A和B都是已经存在的对象
    B = A; 此时会调用拷贝赋值
    // Vector&表示返回Vector类的引用，operator=表示重载运算符=，(const Vector& a)表示传进来的是vector的对象引用
    Vector& ::Vector operator=(const Vector& a){  
    	if(&a == this)	// 如果是传进来的对象是自己，就直接返回去，避免白做工
    		return *this;
    	
    	double* p = new double(a.sz);
    	for(int i = 0; i != a.sz; i++)
    		p[i] = a.elem[i];
    	delete[] elem;  // delete old elements
    	elem = p;
    	sz = a.sz;
    	return *this;
    }

#### 移动构造 ####

移动构造函数

问题与解决

*  **当临时对象在被复制后，就不再被利用了**。我们完全可以把临时对象的资源直接移动，这样就避免了多余的复制操作。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODY2NzM2_size_16_color_FFFFFF_t_70 2][]

*  什么时候该触发移动构造？
    
     *  有可被利用的临时对象
 *  移动构造函数的定义形式：
    
        class_name ( class_name && )
    
    `&&`是右值引用，函数返回的**临时变量**是右值。函数返回时，如果是值传递，会首先生成一个临时变量，因为被调函数内部的定义定义的值会被销毁，所以中间的临时变量是有必要的，但是中间的临时变量是右值，即也是没有特定的存储地址，很快就会被遗弃。

**示例1：函数返回含有指针成员的对象**

**使用深层复制构造函数**

*  返回时构造临时对象，动态分配将临时对象返回到主调函数，然后删除临时对象。

#include<iostream>
    using namespace std;
    
    class IntNum { 
    public:
    	IntNum(int x = 0) : xptr(new int(x)){  //构造函数
    		cout << "Calling constructor..." << endl;
    	}
    	IntNum(const IntNum & n) : xptr(new int(*n.xptr)){ //深层复制构造函数
    		cout << "Calling copy constructor..." << endl;
    	};
    	~IntNum(){  //析构函数
    		delete xptr;
    		cout << "Destructing..." << endl;
    	}
    	int getInt() {  return *xptr; }
    
    private:
    	int *xptr;
    };
    
    //返回值为IntNum类对象
    IntNum getNum() { 
    	IntNum a;
    	return a;
    }
    
    int main() { 
    	cout<<getNum().getInt()<<endl;
    	return 0;
    }
    
    运行结果：
    
    Calling constructor...
    Calling copy constructor...
    Destructing...
    0
    Destructing...

**示例2：函数返回含有指针成员的对象（版本2）**

**使用移动构造函数：**

*  将要返回的局部对象转移到主调函数，省去了构造和删除临时对象的过程。

#include<iostream>
    using namespace std;
    
    class IntNum { 
    public:
    	IntNum(int x = 0) : xptr(new int(x)){  //构造函数
    	cout << "Calling constructor..." << endl;
    }
    	IntNum(const IntNum & n) : xptr(new int(*n.xptr)){ //复制构造函数
    		cout << "Calling copy constructor..." << endl;
    	}
    	
        IntNum(IntNum && n): xptr( n.xptr){  //移动构造函数 其实就是一个抢劫构造函数
    		 n.xptr = nullptr;
    		cout << "Calling move constructor..." << endl;
    	}
    	~IntNum(){  //析构函数
    		delete xptr;
    		cout << "Destructing..." << endl;
    	}
    
    private:
    	int *xptr;
    };
    
    //返回值为IntNum类对象
    
    IntNum getNum() { 
    	IntNum a;
    	return a;
    }
    
    int main() { 
    	cout << getNum().getInt() << endl; return 0;
    }
    
    运行结果：
    
    Calling constructor...
    Calling move constructor...
    Destructing...
    0
    Destructing...

#### 析构函数 ####

*  完成对象被删除前的一些清理工作。（善后）
 *  在对象的生存期结束的时刻系统自动调用它，然后再释放此对象所属的空间。
 *  如果程序中未声明析构函数，编译器将自动产生一个默认的析构函数，其函数体为空。
 *  构造函数和析构函数举例

#include 
    using namespace std;
    class Point {      
    public:
      Point(int xx,int yy);
      ~Point(); // 析构函数不能有参数传递，参数列表为空；也不能有返回值类型
      //...其他函数原型
    private:
      int x, y;
    };

#### 类的组合 ####

*  类中的成员是另一个类的对象。`Person a;`
 *  可以在已有抽象的基础上实现更复杂的抽象。

##### 构造组合类对象时的初始化次序 #####

*  首先对构造函数`初始化列表`中列出的成员（包括基本类型成员和对象成员）进行初始化，初始化次序是成员在类体中定义的次序。
    
     *  成员对象构造函数调用顺序：按对象成员的声明顺序，先声明者先构造。
     *  初始化列表中未出现的成员对象，调用用默认构造函数（即无形参的）初始化
 *  处理完初始化列表之后，再执行构造函数的函数体。

#include <iostream>
    #include <cmath>
    
    using namespace std;
    
    class Point {  //Point类定义
    
    public:
    	Point(int xx = 0, int yy = 0) {  // 构造函数的定义
    		x = xx;
            y = yy;
    	}
    
    	Point(Point &p); // 拷贝构造函数的声明; 拷贝构造函数必须是引用类型对象 &
    
    	int getX() {  return x; } // 成员函数 内联函数
    	int getY() {  return y; }
    
    private:
    	int x, y;
    };
    
    Point::Point(Point &p) {  //拷贝构造函数的实现
    
    	x = p.x;
    	y = p.y;
    	cout << "Calling the copy constructor of Point" << endl;
    }
    
    //类的组合
    class Line {  //Line类的定义
    
        public: //外部接口
    	Line(Point xp1, Point xp2); // 构造函数的声明
    	Line(Line &l);	// 拷贝构造函数
    
    	double getLen() {  return len; }
    
    private: //私有数据成员
    	Point p1, p2; //Point类的对象p1,p2
    	double len;
    };
    
    
    //组合类的构造函数
    Line::Line(Point xp1, Point xp2) : p1(xp1), p2(xp2) {  // : p1(xp1), p2(xp2) 表示“参数列表”
    
    	cout << "Calling constructor of Line" << endl;
    	double x = static_cast<double>(p1.getX() - p2.getX());
    	double y = static_cast<double>(p1.getY() - p2.getY());
    	len = sqrt(x * x + y * y);
    }
    
    Line::Line(Line &l): p1(l.p1), p2(l.p2) { //组合类的拷贝构造函数
    	
        cout << "Calling the copy constructor of Line" << endl;
    	len = l.len;
    }
    
    
    //主函数
    int main() { 
    
    	Point myp1(1, 1), myp2(4, 5); //建立Point类的对象
    	Line line(myp1, myp2); //建立Line类的对象
    	Line line2(line); //利用复制构造函数建立一个新对象
    	cout << "The length of the line is: ";
    	cout << line.getLen() << endl;
    	cout << "The length of the line2 is: ";
    	cout << line2.getLen() << endl;
    
    	return 0;
    }

## 类的前向引用声明 ##

*  类应该先声明后使用
 *  如果需要在某个类的声明之前，引用该类，则应进行`前向引用声明`
 *  前向引用声明只为程序引入一个标识符，但具体声明在其他地方
    
        class B; // 前向引用声明
        class A{ 
        public:
            void f(B b); // 如果是声明和定义函数，这么做没有问题，因为函数在被调用前是不会给其分配内存空间的，即不会实际载入
        };
        class B{ 
        public:
            void g(A,a);
        }

前向引用声明注意事项：

*  用前向引用声明虽然可以解决一些问题，但它并不是万能的。
 *  在提供一个完整的类声明之前 ，不能声明该类的对象，也不能在内联成员函数中使用该类的对象。
 *  当使用前向声明时，只能使用被声明的符号，而不能实现任何类的细节。
    
        class Fred; // 前向引用声明
        class Barney{ 
            Fred x; // 错误：类Fred的声明并不完善
        }；
        class Fred{ 
            Barney y;
        }

## 结构体 ##

*  结构体是一种**特殊形态**的**类**
 *  与类的唯一区别：类的缺省访问权限是`private`，结构体的缺省访问权限是`public`
 *  结构体存在的主要原因：与C语言保持兼容

C++中的`结构体`和`类`没有本质区别，仅仅是`缺省访问权限`不一样，所以C++中的结构体就是类。

所以**结构体**中可以定义`成员函数`。

什么时候用结构体而不用类？

*  主要用来保存一组数据，而几乎没有什么操作
 *  人们习惯将结构体的数据成员设为公有，因此这时用结构体更方便

结构体的定义

struct 结构体名称 { 
    	 公有成员
    protected:
        保护型成员
    private:
         私有成员
    };

结构体的初始化：

如果一个结构体的全部数据成员都是公共成员，并且没有用户定义的构造函数，没有`基类`和`虚函数`（基类和虚函数将在后面的章节中介绍），这个结构体的变量可以用下面的语法形式赋初值：

类型名 变量名 = {  成员数据1初值, 成员数据2初值, …… };

例4-7用**结构体**表示学生的基本信息

#include 
    #include 
    #include 
    using namespace std;
    
    struct Student { 	//学生信息结构体
    	int num;		//学号
    	string name;	//姓名，字符串对象
    	char sex;		//性别
    	int age;		//年龄
    };
    
    
    int main() { 
    	Student stu = {  97001, "Lin Lin", 'F', 19 }; // 结构体的初始化
    	cout << "Num: " << stu.num << endl;
    	cout << "Name: " << stu.name << endl;
    	cout << "Sex: " << stu.sex << endl;
    	cout << "Age: " << stu.age << endl;
    	return 0;
    }
    
    //运行结果：
    Num:  97001
    Name: Lin Lin
    Sex:  F
    Age:  19

## 联合体 ##

**概念明晰：**

枚举类型`enum`、结构体`struct`、联合体`union`他们的定义方式是一样的，都是在定义一种特殊的数据类型，所以在实例化一个对象时，格式是一致的：

数据类型 对象名；
    int num；
    GameResult result；
    Student stu；
    // 哪一种数据类型的对象都是这么声明的

联合体的声明形式

union 联合体名称 { 
        公有成员
    protected:
        保护型成员
    private:
        私有成员
    };

特点

*  成员**共用**一组内存单元，这也就决定了联合体对象同一时间只有一个数据成员
 *  任何两个成员不会同时有效

**发现：** 联合体的作用是对同一内容的多种描述方式的汇集，但同一时间只能有其中一种描述有效，其他的描述会被覆盖

例如对学生某一门成绩的描述：

union Mark { 	//表示成绩的联合体
    	char grade;	//等级制的成绩
    	bool pass;	//只记是否通过课程的成绩
    	int percent;	//百分制的成绩
    }; // 注意分号

匿名联合体没有名称，如下：

union { 
      int i;
      float f;
    }
    // 在程序中可以这样使用：
    i = 10;
    f = 2.2;

**例：使用联合体保存成绩信息，并且输出。**

#include 
    #include 
    using namespace std;
    class ExamInfo { 
    private:
    	string name;	//课程名称
    	enum {  GRADE, PASS, PERCENTAGE } mode; //计分方式 枚举类型
    	union { 
    		char grade;	//等级制的成绩
    		bool pass;	//只记是否通过课程的成绩
    		int percent;	//百分制的成绩
    	};
    public:
    	//三种构造函数，分别用等级、是否通过和百分初始化
    	ExamInfo(string name, char grade)
    		: name(name), mode(GRADE), grade(grade) {  }
    	ExamInfo(string name, bool pass)
    		: name(name), mode(PASS), pass(pass) {  }
    	ExamInfo(string name, int percent)
    		: name(name), mode(PERCENTAGE), percent(percent) {  }
    	void show();
    }
    
    void ExamInfo::show() { 
    	cout << name << ": ";
    	switch (mode) { 
    	  case GRADE: cout << grade;  break;
    	  case PASS: cout << (pass ? "PASS" : "FAIL"); break;
    	  case PERCENTAGE: cout << percent; break;
    	}
    	cout << endl;
    }
    
    int main() { 
    	ExamInfo course1("English", 'B');
    	ExamInfo course2("Calculus", true);
    	ExamInfo course3("C++ Programming", 85);
    	course1.show();
    	course2.show();
    	course3.show();
    	return 0;
    }
    
    // 运行结果：
    English: B
    Calculus: PASS
    C++ Programming: 85

## 枚举类 ##

注意：`枚举类型`继承自C语言，这种类型本质上就是整数的一个子集，安全性不够，设计的不够严谨。

C++新引入的枚举类则进行了改良优化

### 语法形式： ###

enum class 枚举类型名: 底层类型名 { 枚举值列表};
    
    //例如：
    enum class Type {  General, Light, Medium, Heavy};  // 默认的底层类型是int
    enum class Type: char {  General, Light, Medium, Heavy};
    enum class Category {  General=1, Pistol, MachineGun, Cannon};

### 枚举类的优势： ###

*  强作用域：其作用域限制在枚举类中
    
    如：使用Type的枚举值General：
    
        Type::General
 *  转换限制：枚举类对象不可以与整型隐式地互相转换
 *  可以指定底层类型，如：
    
        enum class Type: char {  General, Light, Medium, Heavy};

### 枚举类举例 ###

#include<iostream>
    
    using namespace std;
    
    enum class Side{  Right, Left };
    enum class Thing{  Wrong, Right };  //尽管两个枚举类都有成员Right，但由于强作用域的原因，并不冲突
    
    int main()
    
    { 
    
    Side s = Side::Right;
    Thing w = Thing::Wrong;
    cout << (s == w) << endl;  //编译错误，无法直接比较不同枚举类
    
    return 0;
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODY2NzM2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200717173827169.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODY2NzM2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODY2NzM2_size_16_color_FFFFFF_t_70 1]: /images/20230209/877bfbc879ea42c9a944b72c76e406be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODY2NzM2_size_16_color_FFFFFF_t_70 2]: /images/20230209/6f93a14eae4649aeba7f93ff6335f9c6.png