【C++私房菜】面向对象中的多重继承以及菱形继承

---

一、多重继承

1、多重继承概念

**多重继承（multiple inheritance）**是指从多个直接基类中产生派生类的能力。多重继承的派生类继承了所有父类的属性。尽管看上去与单继承没有什么区别，但是多个基类交织混合产生的细节会带来错综复杂的设计问题与实践问题。

我们在此再一次对单继承和多继承的概念进行阐述：

• 单继承：一个派生类只有一个直接基类。
• 多继承：一个派生类有两个或以上直接基类。

多重继承时，在派生类的派生列表中可以包含多个基类。和单继承相同，多重继承的派生列表页只能包含已经被定义过的类，而且这些类不能是 final 的。要注意的是每个基类都要包含一个访问说明符，举例说明：

// 抽象基类 ZooAnimal
class ZooAnimal {
public:
    ZooAnimal() = default;
	ZooAnimal(const string& name, int age)
		: _name(name), _age(age) {}
	virtual void eat() = 0; // 纯虚函数，需要在派生类中实现
	const string& getName() const { return _name; }
	int getAge() const { return _age; }
protected:
	string _name;
	int _age;
};

// 类 Bear 继承自 ZooAnimal
class Bear : public ZooAnimal {
public:
    Bear() = default;
	Bear(const string& name, int age, const string& furColor)
		: ZooAnimal(name, age), _furColor(furColor) {}
	void eat() override { cout << "Bear " << _name << " is eating." << endl; }
	const string& getFurColor() const { return _furColor; }
private:
	string _furColor;
};

// 派生类 Panda 继承自 Bear 和 Endangered
class Panda : public Bear, public Endangered {
public:
	Panda(const string& name, int age, const string& furColor, int conservationStatus)
		: Bear(name, age, furColor), Endangered(conservationStatus) {}

	void eat() override {
		cout << "Panda " << _name << " is eating bamboo." << endl;
	}
};

// 辅助类 Endangered
class Endangered {
public:
	 Endangered(int conservationStatus)
		: _conservationStatus(conservationStatus) {}
	int getConservationStatus() const { return _conservationStatus; }
private:
	int _conservationStatus;
};

int main() {
	Bear bear("Brown Bear", 5, "Brown");
	bear.eat();
	cout << "Fur Color: " << bear.getFurColor() << endl;
	Panda panda("Giant Panda", 3, "Black and White", 2);
	panda.eat();
	cout << "Fur Color: " << panda.getFurColor() << endl;
	cout << "Conservation Status: " << panda.getConservationStatus() << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

抽象类和纯虚函数我将在后续关于多态的文章进行详细叙述。此处为了方便叙述，我直接进行使用。

• ZooAnimal 类是一个抽象基类，包含动物的名称和年龄，并声明了一个纯虚函数 eat()，需要在派生类中实现。同时提供了获取名称和年龄的方法。
• Bear 类继承自 ZooAnimal 类，表示一种熊，包含了毛色信息（furColor），实现了 eat() 函数并返回熊正在进食的信息。提供了获取毛色的方法。
• Endangered 类是一个辅助类，用于表示濒危物种，包含了保护等级信息（conservationStatus），并提供了获取保护等级的方法。
• Panda 类继承自 Bear 类和 Endangered 类，表示一种熊猫，构造函数中初始化了熊猫的名称、年龄、毛色和保护等级信息。重写了 eat() 函数，输出熊猫正在吃竹子的信息。

---

2、派生类构造函数和析构函数

在此我要提一下在【C++私房菜】面向对象中的简单继承-CSDN博客文章中没有提到的部分，构造一个派生类将同时构造并初始化它的所有基类子对象。与从一个基类进行的派生一样，多重继承的派生类的构造函数初始值只能初始化它的直接基类：

//显示地初始化所有基类
Panda::Panda(const string& name, int age, const string& furColor, int conservationStatus)
		: Bear(name, age, furColor), Endangered(conservationStatus) {}

//隐式地使用Bear的默认构造函数初始化Bear子对象
Panda::Panda()
    	:Endangered() {}
1
2
3
4
5
6
7

派生类的构造函数初始值列表将实参分别传递给每个直接基类。其中基类的构造顺序与派生列表中基类的出现顺序保持一致，而与派生类构造函数初始值列表中基类的顺序无关。一个Panda对象按照如下次序进行初始化：

1. ZooAnimal是整个继承体系的最终基类，Bear是Panda的接基类ZooAnimal是Bear的基类，所以首先初始化ZooAnimal。。接下来初始化Panda的第一个直接基类Bear。
2. 接下来初始化Panda的第一个直接基类Bear。
3. 然后初始化 Panda的第二个直接基类Endangered。
4. 最后初始化 Panda。

派生类析构函数也和往常一样，派生类的析构函数只负责清理派生类本身分配的资源，清理完自己后调用基类的析构函数。

析构函数的调用顺序刚好与构造函数相反，在上述例子中，析构函数调用顺序是 ~Panda 、 ~Endangered 、~Bear和 ~ZooAnimal。

需要注意的是，与只有一个基类的继承是一样的，对象、指针和引用的静态类型决定了我们能够使用哪些成员。如果我们使用 ZooAnimal指针，则只有定义在 ZooAnimal中的操作是可以使用的，Panda接口中的Bear、Panda和Endangered特有的部分都不可见。类似的，一个Bear类型的指针或引用只能访问Bear及ZooAnimal的成员，一个Endangered的指针或引用只能访问Endangered的成员。

---

二、菱形继承和虚继承

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;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

从图中可以明显观察出 D d 对象中存储了两份 _a，造成了数据冗余和二义性的问题。在此对象中A对象存了两份。

尽管在派生列表中同一个基类只能出现一次，但实际上派生类可以多次继承同一个类。派生类可以通过它的两个直接基类分别继承同一个间接基类，也可以直接继承某个基类，然后通过另一个基类再一次间接继承该类。

例如IO库的 istream和 ostream分别继承了一个共同的名为 ios_base 的抽象基类。该抽象基类负责保存流的缓存内容并管理流的条件状态。它提供了从输入设备（如键盘、文件）读取数据的功能。

通过继承 ios_base，istream 和 ostream 类可以共享和继承 ios_base 中定义的功能和状态，以便更方便地进行输入和输出操作。

iostream是另外一个类,它从istream和ostream直接继承而来,可以同时读写流的内容。因为istream和 ostream 都继承自 base_ios，所以 iostream 继承了 base_ios 两次，一次是通过istream，另一次是通过ostream。
在默认情况下，派生类中含有继承链上每个类对应的子部分。如果某个类在派生过程中出现了多次，则派生类中将包含该类的多个子对象。
这种默认的情况对某些形如 iostream 的类显然是行不通的。一个 iostream 对象肯定希望在同一个缓冲区中进行读写操作，也会要求条件状态能同时反映输入和输出操作的情况。假如在 iostream 对象中真的包含了base_ios的两份拷贝，则上述的共享行为就无法实现了，导致菱形继承。

为了避免菱形继承，在 C++语言中我们通过虚继承（virtual inheritance）的机制解决上述问题。虚继承的目的是令某个类做出声明，承诺愿意共享它的基类。其中，共享的基类子对象称为虚基类（virtualbase class）。在这种机制下，不论虚基类在继承体系中出现了多少次，在派生类中都只包含唯一一个共享的虚基类子对象。

我们再次讨论上述代码：

观察这个新的继承体系，我们将发现虚继承的一个不太直观的特征：必须在虚派生的真实需求出现前就已经完成虚派生的操作。例如在我们的类中，当我们定义D时才出现了对虚派生的需求，但是如果 B 和 C 不是从 A 虚派生得到的，那么D的设计者就显得不太幸运了。

在实际的编程过程中，位于中间层次的基类将其继承声明为虚继承一般不会带来什么问题。通常情况下，使用虚继承的类层次是由一个人或一个项目组一次性设计完成的。对于一个独立开发的类来说，很少需要基类中的某一个是虚基类，况且新基类的开发者也无法改变已存在的类体系。

虚派生只影响从指定了虚基类的派生类中进一步派生出的类，它不会影响派生类本身。

我们使用虚基类修改上述代码，我们将 B 和C的虚基类定义为 A 。virtual说明符表明了一种愿望，即在后续的派生类当中共享虚基类的同一份实例：

class A{
public:
	int _a;
};
class B: virtual public A{	//此处关键字public和virtual的顺序随意
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;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

我们需要注意的是不论是基类还是虚基类，派生类对象都能被可访问基类的指针或引用操作。

因为在每个共享的虚基类中只有唯一一个共享的子对象，所以该基类的成员可以被直接访问，并且不会产生二义性。我们观察使用虚继承后的内存窗口可以发现 A只存储一份，但继承的B和 C中有一段未知的地址，我们在对其进行考察（图中类的存放顺序与类的声明顺序相同）：

这里是通过了B和C的两个指针，指向的一张表 。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。即上图中 0x007a7bdc为B的虚基表指针，0x007a7be4为C的虚基表指针。

---

2、虚继承后的构造函数和析构函数

假设我们拥有如上各类代码，且构造继承关系。在虚派生中，虚基类是由最低层的派生类初始化的。即创建 Panda对象时，由 Panda的构造函数独自控制 ZooAnimal的初始化过程。

在此例中，虚基类将会在多条继承路径上被重复初始化。以ZooAnimal为例，如果应用普通规则，则 Raccoon和 Bear 都会试图初始化 Panda对象的 ZooAnimal 部分。
当然，继承体系中的每个类都可能在某个时刻成为“最低层的派生类”。只要我们能创建虚基类的派生类对象，该派生类的构造函数就必须初始化它的虚基类。例如在我们的继承体系中，当创建一个Bear(或Raccoon)的对象时，它已经位于派生的最低层，因此Bear(或Raccoon)的构造函数将直接初始化其ZooAnimal基类部分。

含有虚基类的对象的构造顺序与一般的顺序稍有区别：首先使用提供给最低层派生类构造函数的初始值初始化该对象的虚基类子部分，接下来按照直接基类在派生列表中出现的次序依次对其进行初始化。当我们创建一个 Panda 对象时：

• 首先使用 Panda的构造函数初始值列表中提供的初始值构造虚基类 ZooAnimal部分。

• 接下来构造 Bear部分。

• 然后构造 Raccoon 部分。

• 然后构造第三个直接基类Endangered。

• 最后构造 Panda 部分。

如果 Panda 没有显式地初始化 ZooAnimal基类，则 ZooAnimal 的默认构造函数将被调用。如果ZooAnimal没有默认构造函数，则代码将发生错误。

⚠️虚基类总是先于非虚基类构造，与它们在继承体系中的次序和位置无关。

一个类可以有多个虚基类。此时，这些虚的子对象按照它们在派生列表中出现的顺序从左向右依次构造。编译器会按照直接基类的声明顺序对其进行检查，以确定其中是否含有虚基类。如果有，则先构造虚基类，然后按照声明的顺序逐一构造其他非虚基类。

当然与往常一样，对象的析构顺序与构造顺序正好相反。

三、has-a 与 is-a

面向对象系统中功能复用的两种最常用技术是类继承和对象组合(object composition)。正如我们已解释过的，类继承允许你根据其他类的实现来定义一个类的实现。这种通过生成子类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，父类的内部细节对子类可见。

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。

继承和组合各有优缺点。类继承是在编译时刻静态定义的，且可直接使用，因为程序设计语言直接支持类继承。类继承可以较方便地改变被复用的实现。当一个子类重定义一些而不是全部操作时，它也能影响它所继承的操作，只要在这些操作中调用了被重定义的操作。

但是类继承也有一些不足之处。首先，因为继承在编译时刻就定义了，所以无法在运行时刻改变从父类继承的实现。更糟的是，父类通常至少定义了部分子类的具体表示。因为继承对子类揭示了其父类的实现细节，所以继承常被认为“破坏了封装性” 。子类中的实现与它的父类有如此紧密的依赖关系，以至于父类实现中的任何变化必然会导致子类发生变化。当你需要复用子类时，实现上的依赖性就会产生一些问题。如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活性并最终限制了复用性。一个可用的解决方法就是只继承抽象类，因为抽象类通常提供较少的实现。

对象组合是通过获得对其他对象的引用而在运行时刻动态定义的。组合要求对象遵守彼此的接口约定，进而要求更仔细地定义接口，而这些接口并不妨碍你将一个对象和其他对象一起使用。这还会产生良好的结果：因为对象只能通过接口访问，所以我们并不破坏封装性；只要类型一致，运行时刻还可以用一个对象来替代另一个对象；更进一步，因为对象的实现是基于接口写的，所以实现上存在较少的依赖关系。

对象组合对系统设计还有另一个作用，即优先使用对象组合有助于你保持每个类被封装，并被集中在单个任务上。这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物。另一方面，基于对象组合的设计会有更多的对象 (而有较少的类)，且系统的行为将依赖于对象间的关系而不是被定义在某个类中。

这导出了我们的面向对象设计的第二个原则：优先使用对象组合，而不是类继承。

从概念上来说，多重继承是继承是一种白箱复用，组合是一种黑箱复用。白指看得见内部，黑指看不见内部。从概念上课，本文的多重继承十分简单：一个派生类可以从多个直接基类继承而来。在派生类对象中既包含派生类部分，也包含与每个基类对应的一类部分。虽然看起来很简单，但实际上多重继承的细节非常复杂。特别是对多个基类的继承可能会引入新的名字冲突并造成来自于基类部分的名字的二义性问题。
如果一个类是从多个基类直接继承而来的，那么有可能这些基类本身又共享了另一个基类。在这种情况下，中间类可以选择使用虚继承，从而声明愿意与层次中虚继承同一基类的其他类其享虚基类。用这种方法，后代派生类中将只有一个共享虚基类的副本。