【C++】深入理解 多态

在上一篇文章，我们了解了继承，今天我们来了解一下多态。

多态的概念

多态指 当完成某行为的时候，不同的对象去完成会产生不同的状态。

举个例子：
景区买票，普通人买票 为全价买票；学生买票 为半价买票；军人买票为优先买票。

---

多态的定义及实现

1. 多态的构成条件

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

在继承中要构成多态需要两个条件：

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

我们以之前买票的例子来写一份代码：

#include<iostream>
using namespace std;

class Person
{
public:
	//这里和上一节虚函数用了同一个关键字，实际上没有联系
	virtual void BuyTicket()
	{
		cout << "正常排队-全价买票" << endl;
	}
protected:
	int _age;
	string _name;
};

//学生类
class Student:public Person
{
public:
	void BuyTicket()//重写/覆盖 父类的虚函数
	{
		cout << "正常排队-半价买票" << endl;
	}
protected:

};

//军人类
class Soldier :public Person
{
public:
	void BuyTicket()//重写/覆盖 父类的虚函数
	{
		cout << "不用排队-半价买票" << endl;
	}
protected:

};

void Func(Person& ptr)
{
	//多态 ----ptr 指向父类调用父类的虚函数,指向子类对象调用子类虚函数
	ptr.BuyTicket();
}



int main()
{
	//多态
	Person ps;
	Student st;
	Soldier sd;

	Func(ps);
	Func(st);
	Func(sd);
}	

---

2.虚函数

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

这里需要注意的是： 这里与虚继承使用了同一关键字virtual,但是这两个地方没有关联。

---

3.虚函数的重写

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

这里需要注意的是：在重写基类虚函数的时候，派生类的虚函数是可以不加 virtual关键字的，此时派生类依旧保持了虚函数的属性，但是这种写法不规范，不建议使用。

---

4. 虚函数重写的两个例外

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

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;}
};

---

5.override 和 final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

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

class Car
{
public:
   virtual void Drive() final {}
};

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

2. override : 检查派生类函数是否重写了基类中某个虚函数，没重写就报编译错误

class Car{
public:
   virtual void Drive(){}
};

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

---

6.重载,重写,隐藏的对比

---

抽象类

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;
	}
};

void Test()
{
	Car* pBenz = new Benz;
	pBenz->Drive();
	
	Car* pBMW = new BMW;
	pBMW->Drive();
}

2. 接口继承与实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。

虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。

所以如果不实现多态，不要把函数定义成虚函数。

多态的原理

1. 虚函数表

在介绍虚函数表之前，我们先看一道笔试题：

请问 sizeof(Base) 是多少？

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

结果是12。 _b ，_ch 以及内存对齐 加在一起一共8bytes,我们发现还有四字节是我无法解释的。

观察base的内部，我们发现多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，虚函数表也简称虚表。

那么这个所谓的 虚函数表 放了些什么？

虚函数表中存储了虚函数的地址。

我们写一个单继承的例子，来研究一下虚表的细节：

#include<iostream>
using namespace std;

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

class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()\n" << endl;
	}
	virtual void Func4()
	{
		cout << "Base::Func4()\n" << endl;
	}
private:

	int _d = 2;
};

int main()
{
	Base b;
	Derive d;
	
	return 0;
}

---

我们观察一下调试的结果：

可以恒清晰的看到：

每个虚表指针指向一个vtftable(虚表)，可以理解为一个存储地址数组，每个位置都是 Func函数的地址。

但是， 有一点我们无法解释：为什么Func4()的地址不在 对象d的虚表中。其实并没有什么，只是vs的监视窗口没有显示出来。对于原因我们无法得知，可能是有意为之也有可能是无意之举。

那如何证明Func4的地址在虚表中，第一，我们可以看到编译器提示：“ vtftable[4] ” ，所以很显然，这里有三个函数地址（虚表最后一个位置会放空指针表示本虚表结束） 。第二，我们可以写一个虚表打印函数，直观的观察虚表内容。

---

我们给之前的程序加一个虚表打印函数，以便直观一些：

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

class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()\n" << endl;
	}
	virtual void Func4()
	{
		cout << "Base::Func4()\n" << endl;
	}
private:

	int _d = 2;
};

//打印虚函数表
typedef void(*VFPTR)();

void PrintVFT(void* vft[])
{
	printf("%p\n", vft);
	for (size_t i = 0; vft[i] != nullptr; i++)
	{
		printf("vft[%d]: %p->", i, vft[i]);
		VFPTR f = (VFPTR)vft[i];
		f();
	}
	printf("\n");
}


int main()
{
	Base b;
	Derive d;

	PrintVFT((void**)(*((int*)&b)));
	PrintVFT((void**)(*((int*)&d)));
	return 0;
}

我们运行得到下面的结果，验证了我们的想法：

---

就此，我们可以总结一下：

1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员
2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法
3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会
   放进虚表。
4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
5. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
6. 这里还有一个很容易混淆的问题：虚函数存在哪的？虚表存在哪的？ 答：虚函数存在虚表，虚表存在对象中。注意上面的回答的错的。但是很多童鞋都是这样深以为然的。注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段（常量区）的。

---

2. 多态的原理

讲了那么多，我们也就可以理解多态的原理了。

我们还是以简化的买票的程序为例子：

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 Mike;
	Func(Mike);
	
	Student Johnson;
	Func(Johnson);
	
	return 0;
}

1. 观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是
   Person::BuyTicket。
2. 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？（参考博客：c++多态，为何只能通过指针或引用实现）

1. 如果是一个对象的指针或者引用，直接指向子类对象，不会进行拷贝赋值，这样虚函数表是子类的虚函数表，故能实现多态。

“一个pointer或一个reference之所以支持多态，是因为它们并不引发内存任何“与类型有关的内存委托操作； 会受到改变的。只有它们所指向内存的大小和解释方式 而已”,也就是说：指针和引用并不涉及内存中对象的类型转换，只改变内存的地址和大小

---

2. 而如果是一个对象，无法构成多态。子类对象赋值给父类对象，切片把子类中包含的父类成员变量的值拷贝过去，但是子类的虚表不会给拷贝过去，则函数中这个父类对象的虚表是父类的，所以无法实现多态

6. 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。而不满足多态的函数调用是编译时确认好的。

我们还可以截取一部分汇编代码看一下：

// 以下汇编代码中跟你这个问题不相关的都被去掉了
void Func(Person* p)
{
...
p->BuyTicket();
// p中存的是mike对象的指针，将p移动到eax中
001940DE mov eax,dword ptr [p]
// [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx
001940E1 mov edx,dword ptr [eax]
// [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
00B823EE mov eax,dword ptr [edx]
// call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来以后到对象的
中取找的。
001940EA call eax
00头1940EC cmp esi,esp
}
int main()
{
...
// 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调用转换成地址
//时，是在编译时已经从符号表确认了函数的地址，直接call 地址
mike.BuyTicket();
00195182 lea ecx,[mike]
00195185 call Person::BuyTicket (01914F6h)
...
}

---

3.动态绑定与静态绑定

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