二.继承的总结和反思

1. 很多人说 C++ 语法复杂，其实多继承就是一个体现。有了多继承 ，就存在菱形继承，有了菱 形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设 计出菱形继承。否则在复杂度及性能上都有问题。

2. 多继承可以认为是 C++ 的缺陷之一，很多后来的 OO 语言都没有多继承，如 Java 。

3. 继承和组合

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

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

• 优先使用对象组合，而不是类继承 。

•继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称

为白箱复用 (white-box reuse) 。术语 “ 白箱 ” 是相对可视性而言：在继承方式中，基类的

内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很

大的影响。派生类和基类间的依赖关系很强，耦合度高。

•对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象

来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复

用 (black-box reuse) ，因为对象的内部细节是不可见的。对象只以 “ 黑箱 ” 的形式出现。

组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被

封装。

•实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有

些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用

继承，可以用组合，就用组合。

// 公有继承 -- is-a
class A
{
public:
	void func(){}
protected:
	int _a1;
	int _a2;
};

class B : public A
{};

 组合    -- has-a
class C
{
public:
	void func(){}
protected:
	int _c1;
	int _c2;};

class D
{
private:
	C _cc;
};

如果还是有点不明白，记住万能公式 我是你的什么就用继承， 我有你什么就组合。

比如 我是你的学生，那就继承这个老师的属性。 我有你房子的钥匙，你就用这个套

如果我是你的什么明显语句不通顺。那组合，如果我是你什么 也有你的什么，两个都行那还是组合。

三.多态的概念

1.1 概念

多态的概念：通俗来说，就是多种形态， 具体点就是去完成某个行为，当不同的对象去完成时会 产生出不同的状态 。

举个栗子：比如 买票这个行为 ，当 普通人 买票时，是全价买票； 学生 买票时，是半价买票； 军人 买票时是优先买票。

再比如拼多多新人注册时，得红包更多 那么就你扫码金额 = random()%99，而老用户就只有几角钱 那么就你扫码金额 = random()%1。 

1.2 多态的定义及实现

（1）多态的构成条件

1. 必须通过基类的指针或者引用调用虚函数

2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

 （2）虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数。

virtual void BuyTicket() { cout << "买票-全价" << endl; }

（3）虚函数的重写

虚函数的重写 ( 覆盖 ) ： 派生类中有一个跟基类完全相同的虚函数 ( 即派生类虚函数与基类虚函数的

返回值类型、函数名字、参数列表完全相同 ) ，称子类的虚函数重写了基类的虚函数。

虚函数重写的两个例外：

1. 协变 ( 基类与派生类虚函数返回值类型不同 )

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指

针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。↓

class A{};
class B : public A {};
class Person {
public:
 virtual A* f() {return new A;}
};
class Student : public Person {
public:
 virtual B* f() {return new B;}
};

析构函数的重写 ( 基类与派生类析构函数的名字不同 )

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加 virtual 关键字，

都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，

看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处

理，编译后析构函数的名称统一处理成 destructor 。

class Person {
public:
 virtual ~Person() {cout << "~Person()" << endl;}
};
class Student : public Person {
public:
 virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函
//数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
 Person* p1 = new Person;
 Person* p2 = new Student;

 delete p1;
 delete p2;
 return 0;
}

（4） C++11 override 和 final

从上面可以看出， C++ 对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数

名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有

得到预期结果才来 debug 会得不偿失，因此： C++11 提供了 override 和 final 两个关键字，可以帮

助用户检测是否重写。

1. final ：修饰虚函数，表示该虚函数不能再被重写

2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

（5）  重载、覆盖 ( 重写 ) 、隐藏 ( 重定义 ) 的对比

class Car
{
public:
virtual void Drive() = 0;
};
class Benz :public Car
{
public:
 virtual void Drive()
 {
 cout << "Benz-舒适" << endl;
 }
};
class BMW :public Car
{
public:
 virtual void Drive()
 {
 cout << "BMW-操控" << endl;
 }
};
void Test()
{
Car* pBenz = new Benz;
 pBenz->Drive();
 Car* pBMW = new BMW;
 pBMW->Drive();
}

五.多态的原理

5.1虚函数表

这里常考一道笔试题： sizeof(Base) 是多少？

class Base
{
public:
 virtual void Func1()
 {
 cout << "Func1()" << endl;
 }
private:
 int _b = 1;
};

结果是8 下面我们通过监视来看看 发现里面多了一个_vfptr这个指针。

对象中的这个指针我们叫做虚函数表指针 (v 代 表 virtual ， f 代表 function) 。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数

的地址要被放到虚函数表中，虚函数表也简称虚表，。那么派生类中这个表放了些什么呢？我们接着往下分析↓

5.3 动态绑定与静态绑定

1. 静态绑定又称为前期绑定 ( 早绑定 ) ， 在程序编译期间确定了程序的行为 ， 也称为静态多态 ，

比如：函数重载

2. 动态绑定又称后期绑定 ( 晚绑定 ) ，是在程序运行期间，根据具体拿到的类型确定程序的具体 行为，调用具体的函数，也称为动态多态 。

比如：我们前面分析的基类的指针或引用调用虚函数 ，

六.多继承关系的虚函数表

前面的单继承虚函数表已经演示过了，这里重点讲解多继承的虚函数表

先来一个多继承的代码

class Base1
{
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};
class Base2
{
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
		int b2;
};
class Derive : public Base1, public Base2
{
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};

通过前面的单继承的演示，我们知道不管子类的对象有多少个，都会共用一张虚表。

那多继承的子类会有几张虚表？

通过监视窗口子类有两张虚表。而且先初始化的是Base1的虚表指针。这个根据谁先声明先初始化谁，在多态中谁先继承先初始化谁。