【C++】浅谈C++中的继承

雨点打透心脏的1/2处 2022-06-07 02:11 249阅读 0赞

C++中的继承，作为C++的三大特性之一，是C++中很重要的一部分

## 1.继承的定义 ##

简单讲，继承就是在一个已经存在的类的基础上建立一个新的类，已经存在的类称为基类或父类，新建立的类称为派生类或子类。例如：爸爸继承爷爷的特性，儿子继承爸爸的特性。

派生类的定义：

class DeriveClassName:acess-label BaseClassName \{\}

DeriveClassName：派生类

acess-label：继承类型

BaseClassName：基类

## 2.继承方式，访问限定符 ##

![SouthEast][]

总结为：

（1）在public继承中，基类的非私有成员在派生类中的访问属性不变；

（2）在protected继承中，基类的非私有成员变为派生类中的保护成员；

（3）在private继承中，基类的非私有成员变为派生类中的私有成员。

具体如下：

//public继承
    class B
    {
    public:
    	int b1;
    protected:
    	int b2;
    private:
    	int b3;
    };
    class D :public B
    {
    public:
    	void SetData()
    	{
    		//B b;//B类外定义的对象b，只可以访问公有成员
    		//b.b1 = 1;
    		//b.b2 = 2;
    		//b.b3 = 3;
    		b1 = 1;//基类B的公有成员在D类内仍未公有成员，受保护成员仍为受保护成员，均可以访问
    		b2 = 2;
    		//b3 = 3;
    		d1 = 4;//D类内，D中的成员都可以访问
    		d2 = 5;
    		d3 = 6;
    	}
    	int d1;
    protected:
    	int d2;
    private:
    	int d3;
    };
    int main()
    {
    	//D d;//d中只能访问b1,d1，因为b1,d1是公有成员
    	//d.b1 = 1;
    	//d.d1 = 2;
    	return 0;
    }
    //protected继承
    class B
    {
    public:
    	int b1;
    protected:
    	int b2;
    private:
    	int b3;
    };
    class D :protected B
    {
    public:
    	void SetData()
    	{
    		//B b;//B类外定义的对象b，只可以访问公有成员
    		//b.b1 = 1;
    		//b.b2 = 2;
    		//b.b3 = 3;
    		b1 = 1;//基类B的公有成员，受保护成员在D类内变为受保护成员
    		b2 = 2;
    		//b3 = 3;
    		//d1 = 4;//D类内，D中的成员都可以访问
    		//d2 = 5;
    		//d3 = 6;
    	}
    	int d1;
    protected:
    	int d2;
    private:
    	int d3;
    };
    int main()
    {
    	D d;
    	d.b1 = 1;//因为是保护继承，b1变为protected成员，所以b1不可以访问
    	d.d1 = 2;
    	return 0;
    }
    //private继承
    class B
    {
    public:
    	int b1;
    protected:
    	int b2;
    private:
    	int b3;
    };
    class D :public B
    {
    public:
    	void SetData()
    	{
    		//B b;//B类外定义的对象b，只可以访问公有成员
    		//b.b1 = 1;
    		//b.b2 = 2;
    		//b.b3 = 3;
    		b1 = 1;//基类B的公有成员，受保护成员在D类内变为私有成员
    		b2 = 2;
    		//b3 = 3;
    		d1 = 4;//D类内，D中的成员都可以访问
    		d2 = 5;
    		d3 = 6;
    	}
    	int d1;
    protected:
    	int d2;
    private:
    	int d3;
    };
    int main()
    {
    	D d;
    	//d.b1 = 1;//因为是private继承，b1变为私有成员，所以b1不可以访问
    	//d.d1 = 2;
    	return 0;
    }

注意：（1）.使用关键字class中默认的继承权限为私有的，struct中默认的继承权限公有的。

（2）.不管哪种继承方式，在派生类内部都可以访问基类的公有成员和保护成员，基类的私有成员存在，但在派生类中不可见。

（3）.在实际应用中一般使用public继承。

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

class B
    {
    public:
    	B()
    	{
    		cout << "B()" << endl;
    	}
    	~B()
    	{
    		cout << "~B()" << endl;
    	}
    private:
    	int b1;
    };
    class D :public B
    {
    public:
    	D()
    	{
    		cout << "D()" << endl;
    	}
    	~D()
    	{
    		cout << "~D()" << endl;
    	}
    private:
    	int d1;
    };
    int main()
    {
    	D d;
    	return 0;
    }

![SouthEast 1][]

![SouthEast 2][]

由上图，我们可以发现，在创建派生类对象时，调用构造函数的顺序如下：

派生类构造函数->初始化列表->基类对象的构造（调用基类构造函数）->构造派生类自己特有的成员->派生类构造函数体

需要注意的是：  
（1）基类没有缺省值的构造函数，派生类必须在初始化里表里显式地给出基类名和参数列表。

（2）基类没有定义带参数的构造函数，则派生类可以不用定义构造函数。

程序结束，调用析构函数则与此相反：

派生类析构函数->执行派生类析构函数体->调用基类析构函数

## 4.继承中需要注意的 ##

（1）在继承体系中，基类和派生类是两个不同的作用域。

（2）基类和派生类中有同名成员时，派生类成员将屏蔽基类对成员的直接访问（可以使用 基类::基类成员访问），因此在实际中，尽量避免出现同名成员。

（3）在public继承中（赋值兼容规则）：

子类对象可以赋值给父类；父类对象不能赋值给子类

父类的指针（引用）可以指向子类对象（可以访问父类中的成员，不能访问子类特有的成员）

子类的指针（引用）不能指向父类的对象（可以通过强制类型转换，但不安全）

（4）友元关系不能继承

（5）基类定义了static成员，则整个继承体系中只有一个这样的成员，无论派生了多少子类，都只有一个static成员实例

## 5.单继承，多继承，菱形继承 ##

对象模型：各个成员在内存中的布局形式

（1）单继承

![SouthEast 3][]

（2）多继承

![SouthEast 4][]  
（3）菱形继承

![SouthEast 5][]

![SouthEast 6][]

## 6.虚拟继承 ##

由上图我们可以发现在菱形继承中，C类中的有两个成员b，存在二义性问题，因此，我们引入虚拟继承

虚拟继承 关键字:virtual

虚拟继承与普通继承的区别：

（1）书写形式：虚拟继承添加关键字virtual

（2）对象模型：虚拟继承基类的成员在最下方，比普通继承多4个字节存放地址，改地址指向偏移量表格。  
普通继承基类部分在前，派生类成员在后

偏移量表格：相对于自己的偏移量  
相对于基类的偏移量

（3）对于基类对象的访问形式：普通继承直接访问，虚拟继承通过偏移量表格访问基类对象

（4）构造函数：虚拟继承中的派生类合成构造函数，将偏移量表格地址放入对象前4个字节，同时合成的构造函数多个参数，检测是否为虚拟继承

菱形虚拟继承：

class B
    {
    public:
    	int b1;
    };
    class D1 :virtual public B
    {
    public:
    	int d1;
    };
    class D2 :virtual public B
    {
    public:
    	int d2;
    };
    class C :public D1, public D2
    {
    public:
    	int c;
    };

其对象模型如下：  
![SouthEast 7][]  
由上图，我们可以看到第一个地址是类D1的偏移量表格的地址，在此表格中，相对于自己的偏移量为0，相对于基类的偏移量为0x14；第二个地址，则是D2类的偏移量表格的地址，在此表格中，相对于自己的偏移量为0，相对于基类的偏移量为0x0C。通过偏移量表格访问基类成员，由此解决了菱形继承中的二义性问题。

![SouthEast 8][]

[SouthEast]: /images/20220607/7f8272fb15b14014b0dfb9c5248ef47b.png
[SouthEast 1]: /images/20220607/18803b46637847cf99c4b21a2fed667f.png
[SouthEast 2]: /images/20220607/12f7b28d0fa64a05a2a8544f69152b0a.png
[SouthEast 3]: /images/20220607/0c736666b3ce4e4d87f764645e5fe00d.png
[SouthEast 4]: /images/20220607/809d1eadd2b849d1a2f49a242be39702.png
[SouthEast 5]: /images/20220607/9f4c15330cda4c359312a74d0d19feb8.png
[SouthEast 6]: /images/20220607/2bf55ffdd28d4389894afcbb03184f3f.png
[SouthEast 7]: /images/20220607/c9e40a0c02db4bc894cc7ee87b934906.png
[SouthEast 8]: /images/20220607/31d4c4706409459b939e9def20911f2a.png