C++程序设计【五】之类的继承与派生

矫情吗；* 2022-11-02 11:47 193阅读 0赞

> 感谢内容提供者：[金牛区吴迪软件开发工作室][Link 1]  
> 接上一篇：[C++程序设计【四】之运算符重载的概念][C]

### 文章目录 ###

*  第五章：类的继承与类的派生
 *   *  一、类的继承与类的派生
     *   *  1.继承的概念
         *  2.派生类的定义与大小
         *   *   *  a.派生类的定义
                 *  b.类的大小
                 *  c.继承关系的特殊性
         *  3.继承关系的特殊性
         *  4.有继承关系的类之间的访问
         *  5.protected访问范围说明符
         *  6.多重继承
     *  二、访问控制
     *   *  1.公有继承
         *  2.类型兼容规则
         *  3.私有继承
         *  4.保护继承
     *  三、派生类的构造函数和析构函数
     *   *  1.构造函数与析构函数
         *  2.复制构造函数
         *  3.多重继承的构造函数与析构函数
     *  四、类之间的关系
     *   *  1.类与类之间的关系
         *  2.封闭类的派生
         *  3.互包含关系的类
     *  五、多层次的派生
     *  六、基类与派生类指针的互相转换

# 第五章：类的继承与类的派生 #

## 一、类的继承与类的派生 ##

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

#include <iostream>
    using namespace std;
    
    class another;  // 前向引用声明
    class Base {     // 基类
        private:
            float x;
        public:
            void print(const another &K);
    };
    class Derived:public Base {  // 派生类
        private:
            float y;
    };
    class another { 
        private:
            int aaa;
        public:
            another() { 
                aaa = 100;
            }
            friend void Base::print(const another &K);  // 基类的成员函数声明为本类的友元
    };
    void Base::print(const another &K) { 
        cout << "Base:" << K.aaa << endl;   // 可以访问私有成员变量
    }
    int main() { 
        Base a;
        Derived d;
        another ano;    // aaa初始化为100
        a.print(ano);   // 输出为: Base: 100
        d.print(ano);   // 输出为: Base: 100
        return 0;
    }

### 1.继承的概念 ###

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

### 2.派生类的定义与大小 ###

##### a.派生类的定义 #####

class BaseClass { 	// 基类
    	int v1, v2;
    }
    
    class DeviredClass: public BaseClass { 	// 派生类
    	int v3;
    }

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

class emptyClass { };  // 空基类
    class subemptyClass: public emptyClass { };	// 派生类
    // 派生类可以改变基类中成员的访问权限

##### b.类的大小 #####

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

#include<iostream>
    using namespace std;
    class BaseClass { 	// 基类
    	int v1, v2;
    	char v4;
    	public:
    		int templ() { }
    };
    
    class DerivedClass: public BaseClass { 	// 派生类
    	int v3;
    	int*p;
    	public:
    		int temp() { }
    };
    
    int main() { 
    	cout << "Base=" << sizeof(BaseClass) << endl;	// 输出Base=12
    	cout << "Derived=" << sizeof(DerivedClass) << endl;	// 输出Derived=24
    	return 0;
    }

##### c.继承关系的特殊性 #####

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

### 3.继承关系的特殊性 ###

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

#include<iostream>
    using namespace std;
    class Base {     // 基类
        private:
            float x;
        public:
            static int staV;
            Base() { 
                staV ++;
            }
    };
    int Base::staV = 0;
    class Derived: public Base {     // 派生类
        private:
            float y;
        public:
            Derived() { 
                staV++;
            }
    };
    
    
    int main() { 
        Base a;
        cout << a.staV << endl; // 输出1
        Derived d;
        cout << d.staV << endl; // 输出3
        return 0;
    }

### 4.有继承关系的类之间的访问 ###

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

#include<iostream>
    using namespace std;
    class CB { 
    public:
        int a;
        CB(int x) { 
            a = x;
        }
        void showa() { 
            cout << "Class CB--a = " << a << endl;
        }
    };
    
    class CD:public CB { 
    public:
        int a;  // 与基类a同名
        CD(int x, int y):CB(x) {     // x用来初始化基类的成员变量a
            a = y;
        }
        void showa() { 
            cout << "Class CD--a = " << a << endl;
        }
        void print2a() { 
            cout << "a = " << a << endl;    // 访问派生类a
            cout << "CB::a = " << CB::a << endl;    // 访问基类a
        }
    };
    
    int main() { 
        CB CBobj(12);
        CBobj.showa();
        CD CDobj(48, 999);
        CDobj.showa();  // 访问派生类的showa()
        CDobj.CB::showa();  // 访问基类的showa()
        cout << "CDobj.a = " << CDobj.a << endl;
        cout << "CDobj.CB::a = " << CDobj.CB::a << endl;
        return 0;
    }

### 5.protected访问范围说明符 ###

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

### 6.多重继承 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 9]

#include<iostream>
    using namespace std;
    class CB1 { 
    public:
        int a;  // 重名
        CB1(int x) { 
            a = x;
        }
        void showa() {   // 重名
            cout << "Class CB1 ==> a = " << a << endl;
        }
    };
    
    class CB2 { 
    public:
        int a;  // 重名
        CB2(int x) { 
            a = x;
        }
        void showa() {   // 重名
            cout << "Class CB2 ==> a = " << a << endl;
        }
    };
    
    class CD:public CB1, public CB2 {    // 多重继承，俩个基类
    public:
        int a;  // 与俩个基类成员变量a同名
        CD(int x, int y, int z):CB1(x), CB2(y) { 
            a = z;
        }
        void showa() {   // 与俩个基类成员函数showa()同名
            cout << "Class CD ==> a = " << a << endl;
        }
        void print3a() { 
            cout << "a = " << a << endl;    // 访问派生类a
            cout << "CB1::a = " << CB1::a << endl;    // 访问基类a
            cout << "CB2::a = " << CB2::a << endl;    // 访问基类a
        }
    };
    
    int main() { 
        CB1 CB1obj(11);
        CB1obj.showa(); // 11
        CD CDobj(101, 202, 909);
        CDobj.showa();  // 访问派生类的showa() 909
        CDobj.CB1::showa();  // 访问基类的showa() 101
        cout << "CDobj.a = " << CDobj.a << endl;    // 909
        cout << "CDobj.CB2::a = " << CDobj.CB2::a << endl;  // 202
        return 0;
    }

## 二、访问控制 ##

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

### 1.公有继承 ###

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

### 2.类型兼容规则 ###

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

#include<iostream>
    
    using namespace std;
    
    class A { 
        int an;
    public:
        A() { }
        A(int n) { 
            an = n;
        }
        void printa() { 
            cout << "A:" << an << endl;
        }
    };
    
    class B : public A {   // 共有派生
        int bn;
    public:
        B(int n) : A(2 * n) { 
            bn = n;
        }
        void printa() { 
            cout << "b:" << bn << endl;
        }
    };
    
    int main() { 
        A a(10);
        a.printa(); // 10
        B b(20);
        a.printa(); // 10
        a = b;  // 派生类对象赋值给基类对象
        a.printa(); // 40
        b.printa(); // 20
        return 0;
    }

### 3.私有继承 ###

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

### 4.保护继承 ###

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

## 三、派生类的构造函数和析构函数 ##

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

### 1.构造函数与析构函数 ###

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

#include<iostream>
    
    using namespace std;
    
    class BaseClass {    // 基类
    protected:
        int v1, v2;
    public:
        BaseClass();
        BaseClass(int, int);
        ~BaseClass();
    };
    
    BaseClass::BaseClass() { 
        cout << "BaseClass 无参构造函数" << endl;
    }
    BaseClass::BaseClass(int m, int n) { 
        v1 = m;
        v2 = n;
        cout << "BaseClass 2个参数构造函数" << endl;
    }
    BaseClass::~BaseClass() { 
        cout << "BaseClass 析构函数" << endl;
    }
    class DerivedClass:public BaseClass {    // 公有继承的派生类
        int v3;
    public:
        DerivedClass();
        DerivedClass(int);
        DerivedClass(int, int, int);
        ~DerivedClass();
    };
    
    DerivedClass::DerivedClass() { 
        cout << "DerivedClass无参构造函数" << endl;
    }
    DerivedClass::DerivedClass(int k):v3(k) { 
        cout << "DerivedClass带1个参数构造函数" << endl;
    }
    DerivedClass::DerivedClass(int m, int n, int k):BaseClass(m, n), v3(k) { 
        cout << "DerivedClass带3个参数构造函数" << endl;
    }
    DerivedClass::~DerivedClass() { 
        cout << "DerivedClass析构函数" << endl;
    }
    
    int main() { 
        cout << "无参对象的创建" << endl;
        BaseClass baseCla;  // 基类对象
        DerivedClass derivedCla;    // 派生类对象
        return 0;
    }

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

#include<iostream>
    
    using namespace std;
    
    class Base { 
    private:
        int Y;
    public:
        Base(int y = 0) { 
            Y = y;
            cout << "Base(" << y << ")" << endl;
        }
        ~Base() { 
            cout << "~Base()" << endl;
        }
        void print() { 
            cout << Y << endl;
        }
    };
    
    class Derived:public Base { 
    private:
        int Z;
    public:
        Derived(int y, int z):Base(y) { 
            Z = z;
            cout << "Derived(" << y << "," << z << ")" << endl;
        }
        ~Derived() { 
            cout << "~Derived()" << endl;
        }
        void print() { 
            Base::print();
            cout << Z << endl;
        }
    };
    
    int main() { 
        Derived d(10, 20);
        d.print();
        return 0;
    }

### 2.复制构造函数 ###

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

#include<iostream>
    
    using namespace std;
    
    class CBase { 
    public:
        CBase() { }
        CBase(CBase & c) { 
            cout << "CBase::复制构造函数" << endl;
        }
        CBase & operator=(const CBase &b) { 
            cout << "CBase::operator=" << endl;
            return *this;
        }
    };
    
    class CDerived:public CBase { 
    public:
        CDerived() { 
            cout << "CDerived::复制构造函数" << endl;
        }
    };
    
    int main() { 
        CDerived d1, d2;
        CDerived d3(d1);
        // d3初始化过程中会调用类CBase的复制构造函数
        d2 = d1;    // 会调用类CBase重载的"="运算符
        return 0;
    }

### 3.多重继承的构造函数与析构函数 ###

![20210227203705173.png][]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 19]

## 四、类之间的关系 ##

### 1.类与类之间的关系 ###

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

### 2.封闭类的派生 ###

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

### 3.互包含关系的类 ###

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

class A { 	// 类A的定义
    	public:
    		void f(B b);	// 以类B对象为形参的成员函数
    };
    class B { 	// 类B的定义
    	public:
    		void g(A a);	// 以类A对象为形参的成员函数
    }

## 五、多层次的派生 ##

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

## 六、基类与派生类指针的互相转换 ##

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

#include<iostream>
    
    using namespace std;
    
    class CBase { 
    protected:
        int n;
    public:
        CBase(int i): n(i) { }
        void print() { 
            cout << "CBase:n = " << n << endl;
        }
    };
    class CDerived: public CBase { 
    public:
        int v;
        CDerived(int i): CBase(i), v(2 * i) { }
        void Func() { };
        void print() { 
            cout << "CDerived:n=" << n << endl;
            cout << "CDerived:v=" << v << endl;
        }
    };
    
    
    int main() { 
        CDerived objDerived(3);
        CBase objBase(5);
        CBase * pBase = &objDerived;    // 使用基类指针指向派生类对象
        CDerived *pDerived;
        pDerived = &objDerived;
        cout << "使用派生类指针调用函数" << endl;
        pDerived -> print();    // 调用的是派生类中的函数
        pBase = pDerived;   // 基类指针 = 派生类指针，正确
        cout << "使用基类指针调用函数" << endl;
        pBase -> print();   // 调用的是基类中的函数
        //pBase -> Func() // 错误，通过基类指针不能调用派生类函数
        //pDerived = pBase; // 错误，派生类指针=基类指针
        pDerived = (CDerived*)pBase;    // 强制类型转换，派生类指针=基类指针
        cout << "使用派生类指针调用函数" << endl;
        pDerived -> print();    // 调用的是派生类中的函数
        return 0;
    }

下一篇：[C++程序设计【六】之 多态与虚函数][C_]

[Link 1]: http://wdstudio.top/
[C]: https://wudi98.blog.csdn.net/article/details/111997160
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70]: /images/20221024/f304431900e945c79958b2a8465894cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 1]: /images/20221024/e37c1bed4a3f4b2697d390837259f265.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 2]: /images/20221024/8437620514ba438e8aeec702b547945e.png
[20210226095217536.png]: /images/20221024/a7d869769c44410197dc10f99356a064.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 3]: /images/20221024/2ceaf49a76d74808ad96edeea9aee7cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 4]: /images/20221024/f714f4f0292c48f3ae12150b074a9336.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 5]: /images/20221024/905fb74aab854168b35d991b82cfc55b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 6]: /images/20221024/8606206bf74f4a62a280529206352760.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 7]: /images/20221024/2605fb6234174a4ea196479532191e73.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 8]: /images/20221024/9855fb7451884502b549543a2c0742e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 9]: /images/20221024/9ca7ec8fd4344d7f9872414e830525ad.png
[20210226155235926.png]: /images/20221024/dc45c0b1261c4ab38d2499f2c54481e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 10]: /images/20221024/578006eb59564bfa81e4310e37332a12.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 11]: /images/20221024/059ac89624074298a61fce8d6b2bbdc8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 12]: /images/20221024/644a58c911db4772b889c27a00a00ec5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 13]: /images/20221024/15904fa7eef3460694756c882066a933.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 14]: /images/20221024/68d62f6f72884b78a4f15fcef3b8fd55.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 15]: /images/20221024/7366d7de92cc48bca939f4382797336f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 16]: /images/20221024/02dc615a139c4a40b05ac7f23ed78415.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 17]: /images/20221024/bea8f1e5e94542e3844cdbc13b7f36bb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 18]: /images/20221024/c2964c3e91a0441e846604f73ce4dd2e.png
[20210227203705173.png]: /images/20221024/6c017f34a3be40fe93f740e596766fce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 19]: /images/20221024/ff49919ec9f24ddcb1aff88bb3312121.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 20]: /images/20221024/8737cdab60d4404dac4fac3d2e7f484e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 21]: /images/20221024/fe85ebe9ea12469ebf373cbddedcee21.png
[20210227204742842.png]: /images/20221024/e5bd7086d4a34145a374f9a0eb91d77d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 22]: /images/20221024/b365b47d5d0c4baabd0e75ed60c10b90.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 23]: /images/20221024/515c2ac1cc0f431596390c4e802389d4.png
[C_]: https://wudi98.blog.csdn.net/article/details/114193159