C++ 虚函数详解（虚函数表、vfptr）——带虚函数表的内存分布图

冷不防 2022-02-02 05:57 411阅读 0赞

# 前言 #

总所周知，虚函数是实现多态的基础。

*  引用或指针的静态类型与对象本身的动态类型的不同，才是C++支持多态的根本所在。
 *  当使用基类的引用或指针调用一个虚函数成员时，会执行动态绑定。
 *  所有的虚函数都必须有定义，因为编译器直到运行前也不知道到底要调用哪个版本的虚函数。
 *  只有通过指针或引用调用虚函数才会发生动态绑定，因为只有这种情况，引用或指针的静态类型与对象本身的动态类型才会不同。

# 关于另一篇博客 #

大家在网上搜索关于虚函数的博客应该都会搜到陈皓写的那篇C++ 虚函数表解析吧，这篇文章确实不错，画的图也比较好理解，对于指针理解比较深刻的人应该不会理解错误，但对于新人来说可能还是有点不友好。以下几点我觉得需要强调：

*  虚函数表的指针，实质是指针的指针。
 *  虚函数表的内容，实质是一个指针的数组。（同时辅证了上一点）
 *  在图例中，所以就会两次指针指向的过程。

还有一点就是在该大神的例子程序的输出中，给出的中文解释我认为是错误的，看起来是很容易误导人的。 最开始的例子程序中的：  
`cout << "虚函数表地址：" << (int*)(&b) << endl;`  
`cout << "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&b) << endl;`  
这两句明显错误，本人在困惑之余便开始了自己的验证。  
而且图例中也应该有两次指针指向的过程。

# 虚函数表(vfptr) #

**虚函数表的指针存储在对象实例中最前面的位置。**  
这意味着我们可以**通过对象实例的地址得到这个虚函数表的指针，然后就遍历虚函数表中的各个函数指针，然后调用相应的函数。**  
下面开始各个例子程序的实验！（win10+vs2017）

# 只有基类 #

#include "pch.h"
    #include <iostream>
    using namespace std;
    class Base { 
    
    public:
    
    	virtual void f() {  cout << "Base::f" << endl; }
    
    	virtual void g() {  cout << "Base::g" << endl; }
    
    	virtual void h() {  cout << "Base::h" << endl; }
    
    };
    int main()
    { 
    	typedef void(*Fun)(void);
    
    	Base b;
    
    	Fun pFun = NULL;
    
    	Base * p = &b;
    
    	cout << "该对象的地址：" << p << endl;
    
    	cout << "虚函数表的指针也是从这个地址"<< (int*)(&b) <<"开始存的" << endl << endl;
    
    	cout << "虚函数表的指针指向的地址10进制：" << *(int*)(&b) << "即虚函数表的指针存的内容"<<endl;
    
    	cout << "即虚函数表的地址：" << (int*)*(int*)(&b) << endl << endl;
    
    	pFun = (Fun)*(int*)*(int*)(&b);//第一个虚函数的指针
    
    	cout << "第一个虚函数的地址：" << pFun << endl;
    
    	pFun();
    
    	Fun gFun = NULL;
    	gFun = (Fun)*((int*)*(int*)(&b) + 1);//第二个虚函数的指针
    
    	Fun hFun = NULL;
    	hFun = (Fun)*((int*)*(int*)(&b) + 2);//第三个虚函数的指针
    }

1.  理解内存里每个字节是有编号，这个编号便是我们说的地址。
2.  指针存的是一个地址，我们只关心指针指向的地址（指针存的地址）和指向对象的类型，而不关心指针这个对象本身的地址。
3.  对指针解引用，实际是从指针指向的地址的那个字节开始，按照指向对象的类型的字节大小n，读取n个字节出来，来组成这个类型的对象。
4.  打印指针时，会打印出来指针指向的地址，以16进制。

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

1.  `b`返回`Base`类型的对象。
2.  `&b`返回`Base *`类型的指针。
3.  `(int *)(&b)`将`Base *`类型的指针转换为`int *`类型的指针，转换后指针指向地址没变，但指向对象的类型变了。
4.  `*(int *)(&b)`对`int *`类型的指针解引用，从地址开始的那个字节开始，取出sizeof(int)个字节，赋值给一个int对象（因为指针认为自己指向一个int对象）。
5.  `(int *)*(int *)(&b)`相当于 `(int *)`后接一个int值，返回一个int指针，将这个int值作为该指针指向的地址值。
6.  `*(int *)*(int *)(&b)`对`int *`类型的指针解引用，返回int值。
7.  `(Fun)*(int *)*(int *)(&b)`，Fun是函数指针，后接一个int值，将这个int值作为该函数指针指向的地址值。
8.  如果以上过程你都正确理解，那么你就能理解这句`gFun = (Fun)*((int*)*(int*)(&b) + 1);`了。首先`(int*)*(int*)(&b)`将虚函数表的指针转换为指向指针数组首元素的指针（即转换过程中，指针指向地址没变的），然后`((int*)*(int*)(&b) + 1)`这里就是数组的指针的正常操作，现在这个指针指向了数组的第二个元素（即第二个虚函数指针），最后就是解引用，然后转换为`Fun`函数指针。

如果你还没有理解某个步骤，**建议直接查看以下图例的大图，配合debug显示的局部变量表使用**，再回头看整个过程。  
![在这里插入图片描述][2019051022455063.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70]  
上图解释了虚函数的实现机制：

1.  在有虚函数的基类对象中，肯定至少有三块不同的内存存储区域。
2.  首先是对象内存空间，其开始区域，存了虚函数表的指针。
3.  虚函数表实际是一个指针的数组，这些指针就是虚函数的函数指针。
4.  最后是各个虚函数的存储区域。

# 虚函数表的结束标志 #

在上面例子中还需要讲一个细节，在虚函数表最后位置有一个字节用来标志虚函数表的结束。

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

char* end = NULL;
    	end = (char*)((int*)*(int*)(&b) + 3);

加入如上代码便可以得到结束标志，`((int*)*(int*)(&b) + 3)`这里指向了虚函数表即指针数组的第四个元素，但实际上数组里只有三个指针，所以这里便刚好指向了结束标志。再通过`(char*)`转换指针类型，代表指向的是一个字节。  
![在这里插入图片描述][20190515194945448.png]  
由于我是第二次运行程序，所以地址有点不一样。这里end指针存的地址，按照之前的例子应该是0x00305b38再加12。  
这里你最好再明确下char型存储的含义：（即ASCII表中：是int型<---->char型的相互转换关系）

char end1 = '\0';//字符串的结束符
    	char end2 = 0;//字符串的结束符
    	char zero1 = '0';//这才是真正的字符0
    	char zero2 = 48;

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

# 单继承（无虚函数覆盖） #

在此例中，基类有三个虚函数，派生类也有三个虚函数，但派生类一个虚函数也没有去重写。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 2]

#include "pch.h"
    #include <iostream>
    using namespace std;
    class Base { 
    public:
    
    	virtual void f() {  cout << "Base::f" << endl; }
    
    	virtual void g() {  cout << "Base::g" << endl; }
    
    	virtual void h() {  cout << "Base::h" << endl; }
    
    };
    class Derive : public Base { 
    public:
    
    	virtual void f1() {  cout << "Derive::f" << endl; }
    
    	virtual void g1() {  cout << "Derive::g" << endl; }
    
    	virtual void h1() {  cout << "Derive::h" << endl; }
    
    };
    int main()
    { 
    	typedef void(*Fun)(void);
    	Derive d;
    	Base *p = &d;
    
    	Fun fFun = NULL;
    	fFun = (Fun)*((int*)*(int*)(&d) + 0);//第一个虚函数的指针
    
    	Fun gFun = NULL;
    	gFun = (Fun)*((int*)*(int*)(&d) + 1);//第二个虚函数的指针
    
    	Fun hFun = NULL;
    	hFun = (Fun)*((int*)*(int*)(&d) + 2);//第三个虚函数的指针
    
    	Fun f1 = NULL;
    	f1 = (Fun)*((int*)*(int*)(&d) + 3);
    	Fun g1 = NULL;
    	g1 = (Fun)*((int*)*(int*)(&d) + 4);
    	Fun h1 = NULL;
    	h1 = (Fun)*((int*)*(int*)(&d) + 5);
    
    	char* end = NULL;
    	end = (char*)((int*)*(int*)(&d) + 6);
    }

![在这里插入图片描述][20190515222530836.png]  
虽然虚函数表里只能显示父类的虚函数，但通过增加数组指针的方法，一样可以获得派生类的虚函数指针。就算这里是`Derive *p1 = &d;`也一样，只显示基类的三个虚函数。

*  虚函数指针按照声明顺序放在虚函数表里面。
 *  基类的虚函数在派生类的虚函数前面。

虚函数表的内存模型如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 3]  
但这里我已经厌倦了给每个虚函数生成一个函数指针，所以可以用以下循环：

int main()
    { 
    	typedef void(*Fun)(void);
    	Derive d;
    
    	int *vTable = (int *)*(int *)(&d);//虚函数表的指针
    	for (int i = 0; i<6; ++i)//判断条件写成vTable[i] != 0，有可能会报异常
    	{ 
    		printf("function : %d :0X%x->", i, vTable[i]);
    		Fun f = (Fun)(vTable[i]);
    		f();         //访问虚函数
    	}
    }

![在这里插入图片描述][20190515233020534.png]  
`vTable[i]`相当于给vTable指针加`i`，再解引用。其实就是数组的用法啦，所以就少了解引用的一步。  
打印出来的是各个虚函数的地址。

# 单继承（有虚函数覆盖） #

在此例中，派生类只覆盖了基类的一个函数：f()。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 4]

![在这里插入图片描述][20190515233646532.png]![在这里插入图片描述][20190515233706845.png]  
可以看出：

*  由于f虚函数被重写，原本虚函数表（即指针数组）第一个元素是Base::f()的指针，现在被替换为了Derive::f()的指针
 *  其他虚函数按照之前的顺序排列

虚函数表的内存模型如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 5]

# 多重继承（无虚函数覆盖） #

在此例中，有三个基类，一个派生类，且派生类一个虚函数也没有去重写。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 6]

#include "pch.h"
    #include <iostream>
    using namespace std;
    class Base1 { 
    public:
    	virtual void f() {  cout << "Base1::f" << endl; }
    	virtual void g() {  cout << "Base1::g" << endl; }
    	virtual void h() {  cout << "Base1::h" << endl; }
    };
    class Base2 { 
    public:
    	virtual void f() {  cout << "Base2::f" << endl; }
    	virtual void g() {  cout << "Base2::g" << endl; }
    	virtual void h() {  cout << "Base2::h" << endl; }
    };
    class Base3 { 
    public:
    	virtual void f() {  cout << "Base3::f" << endl; }
    	virtual void g() {  cout << "Base3::g" << endl; }
    	virtual void h() {  cout << "Base3::h" << endl; }
    };
    class Derive : public Base1,public Base2, public Base3 { 
    public:
    	virtual void f1() {  cout << "Derive::f" << endl; }
    	virtual void g1() {  cout << "Derive::g" << endl; }
    	virtual void h1() {  cout << "Derive::h" << endl; }
    };
    typedef void(*Fun)(void);
    void printVfun(int n,int * vTable) { 
    	for (int i = 0; i < n; ++i)
    	{ 
    		printf("function : %d :0X%x->", i, vTable[i]);
    		Fun f = (Fun)(vTable[i]);
    		f();         //访问虚函数
    	}
    	cout << "" << endl;
    }
    int main()
    { 
    	Derive d;
    
    	int *vTable1 = (int *)*(int *)(&d);//第一个虚函数表的指针
    	printVfun(6, vTable1);
    
    	int *vTable2 = (int *)*((int *)(&d)+1);//第二个虚函数表的指针
    	printVfun(3, vTable2);
    
    	int *vTable3 = (int *)*((int *)(&d) + 2);//第三个虚函数表的指针
    	printVfun(3, vTable3);
    }

![在这里插入图片描述][20190516191531808.png]  
![在这里插入图片描述][20190516191600296.png]  
可以看到：

*  对于继承到的每个基类，都有一个对应的虚函数表。
 *  派生类的虚函数的指针，被放进了第一个基类对应的虚函数表里。（按照声明顺序来判断的）

内存模型如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 7]

# 多重继承（有虚函数覆盖） #

在此例中，有三个基类，一个派生类，且派生类重写了三个基类的同一个虚函数。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 8]

#include "pch.h"
    #include <iostream>
    using namespace std;
    class Base1 { 
    public:
    	virtual void f() {  cout << "Base1::f" << endl; }
    	virtual void g() {  cout << "Base1::g" << endl; }
    	virtual void h() {  cout << "Base1::h" << endl; }
    };
    class Base2 { 
    public:
    	virtual void f() {  cout << "Base2::f" << endl; }
    	virtual void g() {  cout << "Base2::g" << endl; }
    	virtual void h() {  cout << "Base2::h" << endl; }
    };
    class Base3 { 
    public:
    	virtual void f() {  cout << "Base3::f" << endl; }
    	virtual void g() {  cout << "Base3::g" << endl; }
    	virtual void h() {  cout << "Base3::h" << endl; }
    };
    class Derive : public Base1, public Base2, public Base3 { 
    public:
    	virtual void f() {  cout << "Derive::f" << endl; }
    	virtual void g1() {  cout << "Derive::g" << endl; }
    	virtual void h1() {  cout << "Derive::h" << endl; }
    };
    typedef void(*Fun)(void);
    void printVfun(int n, int * vTable) { 
    	for (int i = 0; i < n; ++i)
    	{ 
    		printf("function : %d :0X%x->", i, vTable[i]);
    		Fun f = (Fun)(vTable[i]);
    		f();         //访问虚函数
    	}
    	cout << "" << endl;
    }
    int main()
    { 
    	Derive d;
    
    	int *vTable1 = (int *)*(int *)(&d);//第一个虚函数表的指针
    	printVfun(5, vTable1);
    
    	int *vTable2 = (int *)*((int *)(&d) + 1);//第二个虚函数表的指针
    	printVfun(3, vTable2);
    
    	int *vTable3 = (int *)*((int *)(&d) + 2);//第三个虚函数表的指针
    	printVfun(3, vTable3);
    }

![在这里插入图片描述][20190516204040122.png]  
![在这里插入图片描述][20190516204100982.png]  
可以看到：

*  三个基类的虚函数表的第一项，都被替换为Derive::f的指针
 *  这样任意基类指针指向派生类对象，都可以调用到Derive::f

对象模型如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 9]

# 类与虚函数表与虚函数的对应关系 #

注意本章中的示意图都只会关注基类的虚函数指针。或者因为重写，而导致在虚函数表中基类的虚函数指针被替换的情况。（就像局部变量图中的一样）

## 单继承（无虚函数覆盖） ##

在该例中运行：

Base b1;
    	Base b2;
    	Derive d1;
    	Derive d2;

![在这里插入图片描述][20190516222410947.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 10]

*  每一个类对应到一个虚函数表。
 *  两个虚函数表里各个指针指向的地址都是相同的。

## 单继承（有虚函数覆盖） ##

Base b;
    	Derive d;

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 12]

*  基类的虚函数表的三项还是没有变化
 *  派生类的虚函数表的第一项被替换了

## 多重继承（无虚函数覆盖） ##

Base1 b1;
    	Base2 b2;
    	Base3 b3;
    	Derive d;

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

*  派生类因为继承了三个基类，所以会有三张虚函数表。

## 多重继承（有虚函数覆盖） ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 15]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 16]

*  派生类的每个虚函数表的第一项都被替换为Derive::f()的指针了，因为它把三个基类的f虚函数都重写了。

[20190510224440873.png]: /images/20220202/802122b2785a445b830e42d57a3666d3.png
[2019051022455063.png]: /images/20220202/7b681fe16ae3496c90d58b51774e92f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70]: /images/20220202/6bec2f1fe0984471954ba286f1605d7e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 1]: /images/20220202/6b472c8db95542b7929605a05cfbbbd5.png
[20190515194945448.png]: /images/20220202/96fc3528970b4716b73df3d33c8931c7.png
[20190515131345344.png]: /images/20220202/2231ee428f284ec486de10d8656d3307.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 2]: /images/20220202/3f73d61a199b4cf89e52be221c148333.png
[20190515222530836.png]: /images/20220202/eef62f7a7e3c488295046c49b4aecab1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 3]: /images/20220202/24a90c7ccd6f4715ad7a9a1c6ef90659.png
[20190515233020534.png]: /images/20220202/9e8fc09da56a4bc4b9f09ecef1952e82.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 4]: /images/20220202/44ac6ba7f7554162a1612eb35155b2ca.png
[20190515233646532.png]: https://img-blog.csdnimg.cn/20190515233646532.png
[20190515233706845.png]: /images/20220202/0e2424756e1a44308b7c88e0ea2070d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 5]: /images/20220202/3726b698c36d4573bb1a96b351828f55.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 6]: /images/20220202/2ba4f31aef69429494154af82087345c.png
[20190516191531808.png]: /images/20220202/64158c6b07bb4e1b9ef1f853570a7efc.png
[20190516191600296.png]: /images/20220202/5a4d4522e30a4654ad64dd0547222f3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 7]: /images/20220202/05372b3ef41d4446bfb0aadc66edf01b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 8]: /images/20220202/65f3654c44c64db881f0df7f7dd2a666.png
[20190516204040122.png]: /images/20220202/80c0e1232aed40f7b361648023e83e77.png
[20190516204100982.png]: /images/20220202/fe10f3aea8fd455a9dccf73722a24d03.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 9]: /images/20220202/f06aaf689319473aa9441b9d05d21527.png
[20190516222410947.png]: /images/20220202/748a22a3b7d048669d7be9463f2e5420.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 10]: /images/20220202/a02b25e1a3ea44f19e6807e86ac4ba26.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 11]: /images/20220202/c9a96281b518494ca8bb46db5c5b7c05.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 12]: /images/20220202/df3568b8da0c41eaa289ed7d1fad8100.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 13]: /images/20220202/5132b950b2e44c33a8e701d20faaa159.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 14]: /images/20220202/483d725ddb1341a8ae087e59c81227d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 15]: /images/20220202/22aeb118824346bcabc150fe3699bcd1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FubGlhbjUyMw_size_16_color_FFFFFF_t_70 16]: /images/20220202/c46c9d44f6c042e7bcfc38a61dc8e878.png