C++菱形继承_多态

二.继承的总结和反思

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的虚表指针。这个根据谁先声明先初始化谁，在多态中谁先继承先初始化谁。