进阶02 多态

本章重点

1. 多态的概念
2. 多态的定义及实现
3. 抽象类
4. 多态的原理
5. 单继承和多继承的虚函数表
6. 继承和多态常见的面试问题：

1.多态的概念

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

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

2.多态的定义及实现

2.1 多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。
比如 Student 继承了 Person 。 Person 对象买票全价，Student 对象买票半价

那么再继承中要构成多态还有两个条件：

1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

两个条件必须得满足，才能实现多态

2.2 虚函数

虚函数：就是被 virtual 修饰的类成员函数称为虚函数

class Student : public Person
{
public:
	virtual void BuyTicket() 
	{ 
		cout << "买票-半价" << endl;
	}
};

2.3 虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同），称子类的虚函数重写了基类的虚函数。

1. 虚函数的重写（三同）：函数名、参数、返回值，这三个条件必须相同
2. 基类的指针或者引用调用虚函数

= 与 *和& 的切片不一样

int main()
{
	Person pe;
	Student st;
	pe = st;//只拷贝数据,功能(函数)不变
	return 0;
}

在这种情况下再对pe使用(函数)时,使用的是父类的函数,
如果虚函数被拷贝,则会使用子类函数

class Person 
{
public:
	virtual void BuyTicket() 
	{
		cout << "买票-全价" << endl;
	}
};
 
class Student : public Person
{
public:
	virtual void BuyTicket() 
	{ 
		cout << "买票-半价" << endl;
	}
};
 
void Func(Person& p)
{
	p.BuyTicket();
}
 
int main()
{
	Person ps;
	Func(ps);
 
	Student st;
	Func(st);
 
 
	return 0;
}

正常使用多态，对比，去掉引用时的情况：

虚函数重写的三个例外

1. 派生类虚函数可以不加virtual

在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写
（因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性)，
但是该种写法不是很规范，不建议这样使用

class Person 
{
public:
	virtual void BuyTicket() 
	{
		cout << "买票-全价" << endl;
	}
};
class Student : public Person
{
public:
	void BuyTicket() //不加victual也构成多态
	{ 
		cout << "买票-半价" << endl;
	}
};
void Func(Person& p)
{
	p.BuyTicket();
}

2. 析构函数的重写

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加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;
}

如果不给析构函数加virtual，则不会调用派生类的析构函数，可能会导致内存泄漏

3. 协变（返回值可以不同）

基类与派生类虚函数返回值类型不同，必须是父子关系指针或引用（用到不多）

派生类重写基类虚函数时，与基类虚函数返回值类型不同。
即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。（了解）

class Person 
{
public:
	virtual Person* fun() { return this; }
};
class Student : public Person 
{
public:
	virtual Student* fun() { return this; }
};
 
//-----------上面或者下面都称为协变---------------//
 
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; }
};

2.4 C++11的 override 和 final

2.4.1 override

override: 检查派生类虚函数是否重写了基类某个虚函数
用来做检查的，如果派生类的虚函数没有重写某个虚函数，则会进行报错

这也算是一个对虚函数重写的检验，毕竟如果你搞个虚函数，又不去重写，那是不是就没有必要去弄个这个虚函数了

该关键字也是要放在函数名的后面

class Car 
{
public:
	virtual void Drive() {}
};
class Benz :public Car 
{
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

2.4.2 final

final：修饰虚函数，表示改虚函数不能被重写(变为私有)
final关键字要放在函数名的后面

class Car
{
public:
	virtual void Drive() final {}
};
class Benz :public Car
{
public:
    //此时会报错无法重写final修饰的函数
	virtual void Drive() { cout << "Benz-舒适" << endl; }
};

2.4.3 补充:虚继承的私有

1. C++98:采用构造函数/析构函数私有来进行实现不可被继承（应用层面）。

构造私有

class A
{
public:
	static A* CreatObj()
	{
		return new A;
	}
private:
	A()
	{}
};
class B : public A
{
	//原理为父类的私有成员在派生类中不可见。
};
int main()
{
	A* a = A::CreatObj();
	//B b;报错
	return 0;
}

析构私有

class A
{
public:
	void Destory()
	{
		A::~A();
	}
private:
	~A()
	{}
};
class B : public A
{
public:
	//原理为父类的私有成员在派生类中不可见。
};
int main()
{
	A* ptra = new A;
	ptra->Destory();
	operator delete (ptra);
	//B b;
	//报错
	return 0;
}

2. C++11:禁止此类被继承(语法层面)

class A final
{};

//因为B继承A，所以会报错。
class B : public A
{};

2.5 重载、重写（覆盖）、隐藏（重定义）的概念对比

3.抽象类

3.1 概念

• 在虚函数的后面写上 =0 ，则这个函数为纯虚函数。
• 包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。
• 派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。
• 纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

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;
	}
};
 
int main()
{
	Car* pBenz = new Benz;
	pBenz->Drive();
 
	Car* pBMW = new BMW;
	pBMW->Drive();
 
	return 0;
}

3.2 接口继承和实现继承

• 普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。
• 虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。
• 所以如果不实现多态，不要把函数定义成虚函数。

4.多态的原理

4.1 虚函数表-虚表

先来看一道例题：

// 这里常考一道题：sizeof(Base)是多少？
class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
    char _ch;
};
 
int main()
{
	Base bb;
	cout << sizeof(Base) << endl;
 
	return 0;
}

我们根据内存对其原则，可能会想到sizeof（Base)应该是8（32位）

但实际上是12字节，这是因为虚函数内存中有一个虚函数表

对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)
一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。
那么派生类中这个表放了些什么呢？我们接着往下分析

看下面代码进行理解：

1. 我们用一个派生列Son去继承Father
2. Son中重写Func1
3. Father中增加一个虚函数Func2和一个普通函数Func3

class Father
{
public:
	virtual void Func1()
	{
		cout << "Father::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Father::Func2()" << endl;
	}
	void Func3()
	{
		cout << "Father::Func3()" << endl;
	}
private:
	int _f = 1;
};
 
class Son : public Father
{
public:
	virtual void Func1()
	{
		cout << "Son::Func1()" << endl;
	}
private:
	int _s = 2;
};
 
int main()
{
	Father father;
	Son son;
 
	return 0;
}

通过观察和测试，我们发现了以下几点问题：

1. 派生类对象son中也有一个虚表指针，son对象由两部分构成，一部分是父类继承下来的成员，虚表指针的另一部分是自己的成员。
2. 基类 father 对象和派生类 son 对象虚表是不一样的，这里我们发现Func1完成了重写，所以Son的虚表中存的是重写的 Son::Func1，所以虚函数的重写也叫作覆盖
   覆盖就是指虚表中虚函数的覆盖，重写是语法的叫法，覆盖是原理层的叫法。
3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
5. 总结一下派生类的虚表生成：

• 先将基类中的虚表内容拷贝一份到派生类虚表中
• 如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数
• 派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

6. 这里还有一个很容易混淆的问题：虚函数存在哪的？虚表存在哪的？
   注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，
   只是他的指针存到了虚表中。
   另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？
   不同编译器会不一样，我们去验证一下会发现vs下是存在代码段的

4.2 动态绑定与静态绑定

1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

5.单继承和多继承的虚函数表

5.1 单继承中的虚函数表

先来看下面一段代码：

class Base 
{ 
public :
 virtual void func1() { cout<<"Base::func1" <<endl;}
 virtual void func2() {cout<<"Base::func2" <<endl;}
private :
 int a;
};
 
class Derive :public Base 
{ 
public :
 virtual void func1() {cout<<"Derive::func1" <<endl;}
 virtual void func3() {cout<<"Derive::func3" <<endl;}
 virtual void func4() {cout<<"Derive::func4" <<endl;}
private :
 int b;
};

基类 Base 中有两个虚函数 func1() 和 func2() ，
其派生类 Derive 中有三个虚函数表其中 func1() 为虚函数的重写，而func3() 和 func4() 是基类自己新加入的虚函数，那么此时func3() 和 func4（）应该放在哪一个虚函数表中呢？

我们来看监视窗口，我们发现里面看不见func3和func4。
这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。
那么我们如何查看d的虚表呢？下面我们使用代码打印出虚表中的函数。

那么要怎么打印虚函数表呢？

思路：取出b、d对象的头4bytes(32位)，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr

1. 先取b的地址，强转成一个 int* 的指针
2. 再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
3. 再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
4. 虚表指针传递给PrintVTable进行打印虚表
5. 需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了。

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
   // 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
   cout << " 虚表地址>" << vTable << endl;
   for (int i = 0; vTable[i] != nullptr; ++i)
   {
   	printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
   	VFPTR f = vTable[i];
   	f();
   }
   cout << endl;
}
int main()
{
   Base b;
   Derive d;
   VFPTR* vTableb = (VFPTR*)(*(int*)&b);
   PrintVTable(vTableb);
   VFPTR* vTabled = (VFPTR*)(*(int*)&d);
   PrintVTable(vTabled);
   return 0;
}

得到如下结果：
在继承之后，会有两个虚函数表，一个是基类的虚函数表，一个是派生类的基函数表，然后，派生类自己新加的虚函数，会放到派生类的虚函数表中。

5.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;
	int bb;
};
 
class Derive : public Base2, public Base1 
{
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};
 
// 用程序打印虚表
typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
 
int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb1);
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb2);
	return 0;
}

观察结构可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中

补充: 运行结果fun1()的地址竟然不同，这是为什么呢？
将上述代码进行简化：

#include<iostream>
using namespace std;
class A
{
public:
	virtual void fun1()
	{
		cout << "A::fun1()" << endl;
	}
	int _a = 0;
};
class B
{
public:
	virtual void fun1()
	{
		cout << "B::fun1()" << endl;
	}
};

class C : public A, public B
{
public:
	virtual void fun1()
	{
		cout << "C::fun1()" << endl;
	}
};

int main()
{
	C c;
	B* b = &c;
	A* a = &c;

	a->fun1();
	b->fun1();
	return 0;
}

调用函数的反汇编流程图：

可见，b对象在调用真正的fun1时拐了一个弯，然后再调用fun1。

为什么要这样这样做呢？

• 看关键动作——对ecx减8，ecx存放的是this指针，对this指针减8，到C对象的this指针位置，通过C的this指针再进行调用fun1。为什么要这样做呢？因为fun1的作用域是C的类域，直接用B的this指针显然不合理。
• 因此：调整B的this指针是为了类域的独立性，那A对象为什么不用呢？因为A的this指针本就可以当做D的this指针(重合)进行使用，没必要再偏(eax看值不看对象)。

5.3 菱形继承、菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的 模型，访问基类成员有一定得性能损耗。

所以菱形继承、菱形虚拟继承我们的虚表这里就不过多介绍了（本人能力有限），一般我们也不需要研究清楚，因为实际中很少用。

有兴趣的可以去看下面的这两篇文章。

1. C++虚函数表解析
2. C++对象的内存布局

6.继承和多态常见的面试问题

6.1 概念考察

1. 下面哪种面向对象的方法可以让你变得富有( )
   A: 继承 B: 封装 C: 多态 D: 抽象

2. ( )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联于具体的对象。
   A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定

3. 面向对象设计中的继承和组合，下面说法错误的是？（）
   A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复用，也称为白盒复用
   B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动态复用，也称为黑盒复用
   C：优先使用继承，而不是组合，是面向对象设计的第二原则
   D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封装性的表现

4. 以下关于纯虚函数的说法,正确的是( )
   A：声明纯虚函数的类不能实例化对象
   B：声明纯虚函数的类是虚基类
   C：子类必须实现基类的纯虚函数
   D：纯虚函数必须是空函数

5. 关于虚函数的描述正确的是( )
   A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型
   B：内联函数不能是虚函数
   C：派生类必须重新定义基类的虚函数
   D：虚函数可以是一个static型的函数

6. 关于虚表说法正确的是（ ）
   A：一个类只能有一张虚表
   B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
   C：虚表是在运行期间动态生成的
   D：一个类的不同对象共享该类的虚表

7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（ ）
   A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
   B：A类对象和B类对象前4个字节存储的都是虚基表的地址
   C：A类对象和B类对象前4个字节存储的虚表地址相同
   D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表

8. 下面程序输出结果是什么? （）

#include<iostream>
using namespace std;

class A{
public:
 A(char *s) { cout<<s<<endl; }
 ~A(){}
};

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

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

class D:public B,public C
{
public:
 D(char *s1,char *s2,char *s3,char *s4):B(s1,s2),C(s1,s3),A(s1)
 { cout<<s4<<endl;}
};

int main() {
 D *p=new D("class A","class B","class C","class D");
 delete p;
 return 0;
}

A：class A class B class C class D
B：class D class B class C class A
C：class D class C class B class A
D：class A class C class B class D

9. 多继承中指针偏移问题？下面说法正确的是( )

class Base1 { public:  int _b1; };
class Base2 { public:  int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main() 
{
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;
 
	return 0;
}

选项

A：p1 == p2 == p3         B：p1 < p2 < p3         C：p1 == p3 != p2         D：p1 != p2 != p3

10. 以下程序输出结果是什么（）

class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
	virtual void test() { func(); }
};
 
class B : public A
{
public:
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
 
int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}

选项

A: A->0     B: B->1     C: A->1     D: B->0     E: 编译出错     F: 以上都不正确

答案选B，原因如下：

1. 首先看上述代码构不构成多态，
   1）虚函数的重写，构成（三同不包含缺省值），子类继承了父类的virtual
   2）父类指针的调用，满足，p->test() 相当于把一个子类对象传给父类指针

2. 构成多态，那我们去推，可能会觉得答案时D
   但是，要记得子类是会继承父类接口的，所以子类不光继承了父类的virtual，还继承了父类的缺省值，所以此时val=1

即:重写只重写{}中(实现)的内容,父类的壳(接口)不会覆盖

总答案:
1.A 2.D 3.C 4.A 5.B
6.D 7.D 8.A 9.C 10.B

6.2 问答题

1. 什么是多态？

静态多态:函数重载

动态多态:继承中的虚函数重写+父类指针(引用)调用

更方便和灵活的多种形态的调用

2. 什么是重载、重写(覆盖)、重定义(隐藏)？

3. 多态的实现原理？答：参考本节课件内容

静态:函数名修饰规则

动态:虚函数表

4. inline函数可以是虚函数吗？

可以，不过编译器就忽略inline属性，这个函数就不再是inline，因为虚函数要放到虚表中去。

5. 静态成员可以是虚函数吗？

答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
无法实现多态,语法强制检查

6. 构造函数可以是虚函数吗？

答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的(先续虚指针,再成员函数)。

7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？

答：可以，并且最好把基类的析构函数定义成虚函数。

8. 对象访问普通函数快还是虚函数更快？

答：
首先如果是普通对象，是一样快的。

如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。

9. 虚函数表是在什么阶段生成的，存在哪的？

答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。

10. C++菱形继承的问题？虚继承的原理？

答：注意这里不要把虚函数表和虚基表搞混了。

11. 什么是抽象类？抽象类的作用？

答：抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。