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

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

1.继承的定义

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

派生类的定义：

class DeriveClassName:acess-label BaseClassName {}

DeriveClassName：派生类

acess-label：继承类型 

BaseClassName：基类

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

总结为：

（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;
}

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

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

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

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

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

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

4.继承中需要注意的

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

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

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

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

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

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

（4）友元关系不能继承

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

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

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

（1）单继承

（2）多继承

（3）菱形继承

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;
};

其对象模型如下：

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