C++继承相关总结

前言

本文主要是对C++三大特性之一的继承进行讲解。将会围绕继承的概念，继承的语法，继承方式，多继承中的菱形继承以及产生的问题进行介绍。

1.继承的相关概念

1.继承概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

2.继承的相关语法

在对继承语法进行介绍之前，我们先看看如下示例代码。

#include<iostream>
using namespace std;
class Person
{
public:
	void Print()
	{
		cout << _name <<" " << _age << endl;;
	}
private:
	string _name ="aaa";
     int _age=11;
};

class Student :public Person
{
   
private: 
	int _id;
};
int main()
{
	Student s;
	s.Print();
}

通过上述简单示例我们不难看出继承就是一种代码复用的手段。students类被称为派生类，也被称为子类，Preson被称为父类也叫做基类。这里继承方式是public公有继承。 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这点和我们现实世界比较像比如儿子继承父亲的遗产。这里继承被分为3种方式，分别是public共有继承，protected保护继承，private私有继承。

这里我们可以看出如下几点：1基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它.通俗来说不可见就是不能用。2.基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。3.基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。 4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

其实我们这里可以看出父类中的被private修饰的成员是用来防儿子的，protected修饰的成员是用来防外人的。

---

3.基类和派生类对象赋值转换(赋值兼容规则）

派生类对象可以赋值给基类的对象/基类的指针/基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。但是要注意，基类对象不能赋值给派生类对象。也就是说父不能给给子，但是子可以给给父。可以抽象的理解为不能啃老。这里发生赋值兼容的时候并没有发生隐式类型转换，没有产生临时变量，这里是天然支持的。

基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。也就说基类的指针的是可以通过强制类型转化赋值给一个派生类指针，但是不建议这么做，最好是基类指针指向的一个派生类对象。因为派生类的对象的空间的会比基类大，这样做可能会引发越界访问的问题。

2.继承中的注意事项

1.继承中的作用域

在继承体系中基类和派生类都有独立的作用域。子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。注意在实际中在继承体系里面最好不要定义同名的成员。

这里Student中有_name的成员变量，但是父类也有一个_name的成员变量。如果不指定的话默认是Studnet对象在调用Print函数时默认是打印Student类中的成员变量_name，这里是根据就近原则来的。

这里父类和子类都有一个函数Print这里子类在调用Print函数会调用子类自己的Print函数，这里就会构成函数隐藏。这里不是函数重载，函数重载的前提条件是在同一作用域下的两个函数。子类和父类的函数名相同就会构成隐藏。

构成函数隐藏后如果想使用父类的成员函数必须指定类域，不然就会程序报错。

2.派生类的默认成员函数

1.构造函数与拷贝构造

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

从上述代码中不难看出无论如何子类从父类那里继承得来的变量都会先调用父类构造函数先初始化。

同样的子类的拷贝构造函数必须调用父类的拷贝构造完成继承下来的父类的成员变量拷贝初始化。

我们之前讲了父类与子类的赋值兼容规则，因此s虽然是子类类型的引用，但是通过切片处理依然可以调用父类的拷贝构造进行初始化。

2.赋值重载与析构

派生类的operator=也必须要调用基类的operator=完成基类的复制，但是有个点要注意：因为父类与子类赋值重载的函数名是一样的，会构成隐藏，这样就得显示指定一下作用域。

析构函数就和之前的有所区别了，子类的析构函数不用我们显示写，子类对象在调用完析构函数后，编译器会自动调用父类的析构函数再去析构从父类那里继承下来的成员。派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。因为对于子类对象来说，我们是先构造从父类那里继承下来的成员，之后在构造子类自己的成员。我们知道先构造的应该被后析构所以说这里是为了保证析构顺序。

3.友元关系与静态成员变量

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。抽象理解为:父亲的朋友不是儿子朋友。

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 。静态成员变量对子类来说只有一份示例 对于父类来说也是只有一份实例 静态成员这份实例是被父类和子类共享的,静态成员变量是属于类的被所有对象共享。

---

补充一道很有意思的题目

如何设计一个不能被继承的类呢?其实我们把该类的构造函数或者析构函数设为私有即可。

那可能会有人问我怎么创建销毁对象，这里我们可以提供一个静态方法就行了。比如我以构造函数为例。

这样设计出了一个不能被继承的类。

3.多继承(菱形继承)

以上都是单继承，继承还可以多继承。单继承：一个子类只有一个直接父类时称这个继承关系为单继承。 多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承。

多继承但是会引发一个特别的大的问题，就是菱形继承。菱形继承是一种特殊的多继承，即两个派生类继承同一个基类，同时两个派生类又作为基类继承给另一个派生类。

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。

代码示例

#include<iostream>
using namespace std;
class A
{
public:
	int _a;
};

class B :  public  A
{
public:
	int _b;
};
class C : public A
{
public:
	int _c;
};
class D :public B, public C
{
public:
	int _d;
};
int main()
{
	D d1;
	d1.B::_a = 1;
	d1.C::_a = 2;
	d1._b = 3;
	d1._c = 4;
	d1._d = 5;

}

菱形继承的对象成员模型图

这里就看出来了D类中有两份a，这样就会数据冗余造成空间资源的浪费。同时也会造成二义性，我们访问_a的时候到底是访问哪个_a呢？也许有人会说我们指定一下类域不就行了，但是空间资源的浪费怎么解决呢？而且正常来说我们肯定是想只有一份_a数据，就像我们只有只有唯一一个身份证号一样。为了解决菱形继承引发的问题，C++中引入了虚拟继承的概念。

1.虚拟继承

我们先来看看虚拟继承的语法在来探究一下虚拟继承背后的原理。

我们看到D的父类B,父类C通过关键字virtual采用虚拟继承的方式去继承A类，这样我们D类在继承BC的时候就不会有数据冗余和二义性的问题了。要注意的是虚拟继承不要在其他方去使用。

2.虚拟继承的背后原理

vs的监视窗口不能很好的观察，我将通过vs的内存窗口去观察一下这个D的对象模型。

从上图中我们可以看到D从b那里继承了_b外还有一个指针，这个指针被称为虚基指针，这个指针是指向一个虚基表这个表里存放相对于_a位置的偏移量，同样的对C来说也是如此。虚拟继承的原理是在派生类中添加一个虚基指针（vbp），指向一个虚基表（vbt），虚基表中存放了基类的偏移量。当派生类的对象要访问基类的成员时，就可以通过虚基指针和虚基表找到基类的地址，从而访问基类的成员。当D类的对象要访问A类的成员时，就可以通过虚基指针和虚基表找到A类的地址，从而访问A类的成员。

关于虚基类与虚基表的补充

上述例子中A是虚基类，因为它被B类和C类以虚拟继承的方式继承了。虚基类是指在菱形继承结构中，被多个派生类以虚拟继承的方式共同继承的基类。虚基表中存放的是虚基类相对于派生类对象的偏移量，虚基表不在虚基类或派生类里，而是在额外的空间中。虚拟继承确实会增加一些空间开销，因为每个虚拟继承的类都需要一个虚基指针和一个虚基表。但是，虚拟继承也可以避免菱形继承造成的数据冗余和二义性的问题，因为虚基类只会在最终的派生类中存在一份拷贝。

使用虚拟继承的派生类才有自己的虚基表。例如，对于A类，它是一个虚基类，但它并没有自己的虚基表，也没有虚基指针。对于B类和C类，它们是使用虚拟继承的派生类，所以它们有自己的虚基表和虚基指针。对于D类，它是一个多重继承的派生类，它也有自己的虚基表和虚基指针，但是它只继承了B和C的虚基指针，而不是A的。虚基指针除了指向虚基表外，还有一个作用是用于确定对象的类型。当一个对象被转换为一个虚拟继承的基类的指针时，它的虚基指针会被调整为指向该基类的虚基表。这样就可以通过虚基指针来判断对象的真实类型。D * d = new D();B * a = d;这个时候d的虚基指针会调整为指向B的虚基表。

补充一道面试题

class A
{
public:
	A(string s)
	{
		cout << s << endl;
	}

};
class B :virtual public A
{
public:
	B(string s1,string s2)
		:A(s1)
	{
		cout << s2 << endl;
	}
};
class C:virtual public A
{
public:
	C(string s1, string s2)
		:A(s1)
	{
		cout << s2 << endl;
	}

};
class D :public B, public C
{
public:
	D(string s1, string s2, string s3, string s4)
		:
		C(s1,s3),
		B(s1, s2),
		A(s1)
		
	{
		cout<<s4<<endl;
	}
};
int main()
{
	D d1("classA","classB","classC","classD");
}

这里打印结果是什么呢？实现是用菱形继承所以D构造的的时候对于s1 s2 s3 s4来说只会调用一次构造函数,也就是说s1会被A的构造函数调用打印，s2会被B的构造函数调用打印，s3会被C的构造函数调用打印，我们知道初始化列表的顺序是声明顺序。所以这里A先被继承之后再是BC被继承，所打印结果是classA clasB classC classD.

总结

在上述例子中B C虚拟继承A，B C中就会各自一个虚基指针指向各自的虚基表。D继承BC的时候会继承BC的虚基指针，也就是说D的虚基指针是BC虚基指针的组合，同样的D的虚基表也就是B C虚基表的组合。这样就解决了数据冗余问题和二义性。

4.继承总结与反思

很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承否则在复杂度及性能上都有问题。多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。

1. 继承和组合

public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。简单来说，就是车是交通工具这就是is-a的关系，车里有发动机这就是has-a的关系。

优先使用对象组合，而不是类继承 。继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系如果可以用继承，也可以用组合，首选用组合。

以上内容如有问题，欢迎指正！