C++第三十一弹---C++继承机制深度剖析(下)

✨个人主页： 熬夜学编程的小林

💗系列专栏： 【C语言详解】 【数据结构详解】【C++详解】

1.菱形继承及菱形虚拟继承

1.1 单继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承。

Student的直接父类是Person，PostGraduate的直接父类是Student，且都只有一个直接父类，因此均为单继承。

注意：

PostGraduate类只是间接继承了Person，因此依旧为单继承关系。

1.2 多继承 

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承。

Assistant子类既继承了Student父类，又继承了Teacher父类，且均为直接继承，因此为多继承关系。 

1.3 菱形继承

菱形继承：菱形继承是多继承的一种特殊情况，如下图：

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

从上图我们可以看到，Assistant 类既继承了 Student 类又继承了 Teacher 类 ，而 Student 类和 Teacher 类又都继承了 Person 类， 因此 Assistant 类中有两份 Person 的成员，这也就是菱形继承所带来的数据冗余和二义性问题。

class Person
{
public:
	string _name; // 姓名
};
class Student : public Person
{
protected:
	int _num; //学号
};
class Teacher : public Person
{
protected:
	int _id; // 职工编号
};
// Assistant有两份Person类，存在数据冗余和二义性问题
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

 主函数

int main()
{
	Assistant a;
	// a._name = "peter"; // 这样会有二义性无法明确知道访问的是哪一个
	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
}

监视窗口 

从监视窗口我们可以看到，Assistant类确实有两个_name成员，且不相同，即存在数据冗余问题。

解决办法：

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和
Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。

class Person
{
public:
	string _name; // 姓名
};
// 腰部加virtual关键字，构成虚拟继承
class Student : virtual public Person
{
protected:
	int _num; //学号
};
// 腰部加virtual关键字，构成虚拟继承
class Teacher : virtual public Person
{
protected:
	int _id; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

主函数 

int main()
{
	Assistant a;
	a._name = "peter"; 
}

 测试结果

1.3.1 虚拟继承解决数据冗余和二义性的原理

为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成
员的模型。

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 d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
}

下图是菱形继承的内存对象成员模型：这里可以看到数据冗余。

虚拟继承代码 

class A
{
public:
	int _a;
};
class B : virtual public A
{
public:
	int _b;
};
class C : virtual public A
{
public:
	int _c;
};
class D : public B, public C
{
public:
	int _d;
};

 主函数

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
}

下图是菱形虚拟继承的内存对象成员模型：这里可以分析出D对象中将A放到了对象组成的最下
面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指
向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量，通过偏移量
可以找到下面的A(虚基类)。

 

B 和 C 对象也满足菱形虚拟继承的对象模型

int main()
{
    B* pb = &d;
    C* pc = &d;
    return 0;
}

画图演示

下面是上面的Person关系菱形虚拟继承的原理解释：

总结：

在实践中可以设计多继承，但是切记不要实现菱形继承，因为太复杂，容易出各种问题。

2.继承的总结和反思

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

        public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。

        组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

// 组合 一个类中的包含另一个类 has-a 关系
class A
{
private:
	int _a;
};

class B
{
private:
	A _aa;
	int _b;
};

组合和继承很类似，都可以使用其他类的成员，但是组合只能使用public成员，而继承既可以使用public成员，也可以使用protected成员，除此之外还能间接使用private成员。

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

低耦合：类和类之间，模块与模块之间关系不那么紧密，关联不高。

高耦合：类和类之间，模块与模块之间关系很紧密，关联很高。

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。

实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。 

总结：

适合is-a关系(学生是人)，就用继承；适合has-a关系(汽车有轮胎)，就用组合；is-a 和 has-a 关系都可以(栈是特殊的链表，栈有链表)，就用组合。

3.笔试面试题

1. 什么是菱形继承？菱形继承的问题是什么？

        存在四个类，分别是person，student，teacher，assistant，student和teacher分别继承自person，assistant同时继承student和teacher，这种现象就是菱形继承，更深层次的说，assistant内部维护了两份person的成员变量，一份来自student，一份来自person，菱形继承是一种特殊的多继承。
  因为维护了两份person的成员变量，因此，在使用的时候，不知道是使用的来自teacher还是student，因此会存在数据冗余和二义性的问题。

2. 什么是菱形虚拟继承？如何解决数据冗余和二义性的

        菱形虚拟继承是一种解决菱形继承问题的技术。在 C++ 中，通过虚继承（virtual inheritance）可以确保最基类在菱形继承结构中只被继承一次，从而避免数据冗余和二义性问题。

        菱形虚拟继承通过使用virtual关键字来修饰共同的基类，确保了子类在继承多个拥有共同基类的父类时，只会在内存中保留一份基类数据，并且使用唯一的基类指针来访问基类成员，从而解决了数据冗余和二义性的问题。

3. 继承和组合的区别？什么时候用继承？什么时候用组合？

        public继承是一种is-a的关系，也就是说每一个派生类对象都是一个基类对象，组合是一种has-a的关系，假设B组合了A，每一个B对象中都有一个A对象。继承一定程度上破坏了基类的封装性，基类的改变对于派生类有很大的影响，派生类和基类间的依赖关系很强，耦合度很高。并且这种通过派生类的方式的复用通常被称为白箱复用（white-box reuse）。对象通过组合来获得更多功能，要求被组合的对象有良好定义的接口，这种复用风格称为黑箱复用，组合类之间没有很强的依赖关系，耦合度低。

        适合is-a关系(学生是人)，就用继承；适合has-a关系(汽车有轮胎)，就用组合；is-a 和 has-a 关系都可以(栈是特殊的链表，栈有链表)，就用组合。