C++：多态

多态

一、多态的概念

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

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

想要定义出多态需要有这两个条件：

1. 调用函数的对象必须是指针或者引用
2. 父类和子类中被调用的函数必须是虚函数（在函数前面加上virtual关键字），完成虚函数的重写，重写就是要函数完全相同，包括返回值，函数名，参数。重写也叫做覆盖。

如下代码，就实现了买票的多态：

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "成人买票：全价" << endl;
	}
};
class Student :public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "学生买票：半价" << endl;
	}
};
void Buy(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person p;
	Student s;
	Buy(p);
	Buy(s);
	return 0;
}

具体调用过程如下：

打印结果：

虚函数的重写的例外情况

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

2. 不规范的多态写法
   父类中是虚函数，子类中不是虚函数，也构成多态。因为多态其实是基于继承的一个操作，子类会继承父类的成员函数和成员变量。
   但是如果子类有虚函数，父类没有虚函数，那么就不构成虚函数，会构成隐藏（重定义）。

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "成人买票：全价" << endl;
	}
};
class Student :public Person
{
public:
	void BuyTicket()
	{
		cout << "学生买票：半价" << endl;
	}
};

二、析构函数的多态

基类的析构函数一般都建议定义为虚函数，因为不构成多态要看它的类型，如果是多态看的是对象。

比如下面这个特殊情况，一个父类的指针有可能指向一个父类对象，也有可能指向一个子类对象，那么当它进行释放的时候是会根据对象调用它的析构函数的，那也就是说如果是一个父类的对象就要去掉父类的析构，如果是一个子类的对象就要去掉子类的析构，那么也就是说不同的对象去调就会有不同的结果！！啊啊！！那这不就是多态么！

所以当我们把父类的析构定义为虚函数的时候，因为继承的关系，所以子类的析构函数也会变成虚函数，父类的析构和子类的析构就会构成重写，就构成了多态。因此如果一个父类的指针指向子类的对象的时候也不用担心了，构成多态的时候是根据类型来进行调用的，是子类对象来调用所以必然会去调用子类的析构函数。

有盆友可能会疑问：~Person()和~Student()怎么能构成多态呢？这俩函数名都不一样啊！其实编译器底层会把析构函数都命名为destructor，所以其实他们俩其实是同名的哈哈。

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	~Student() { cout << "~Student()" << endl; }
};
int main()
{
	Person* p = new Student;//父类的指针指向子类对象
	delete p;
	return 0;
}

三、抽象类

抽象类就是含有纯虚函数的类，纯虚函数就是在父类的虚函数后面写上=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;
	}
};

纯虚函数的作用：

1. 实现抽象类
2. 体现接口继承
3. 强制重写

四、C++11 override 和 final

C++11中引入了两个关键字来修饰虚函数。

override：修饰派生类虚函数强制完成重写，如果没有重写会编译报错
override可以用于检查派生类是否完成了重写。

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

final：被final修饰过的虚函数被继承以后无法完成重写

class Car
{
public:
	virtual void Drive() final {}
};
class Benz :public Car
{
public:
	//报错，提示无法完成重写
	//virtual void Drive() 
	//{ 
	//	cout << "Benz-舒适" << endl; 
	//}
};

五、多态的原理

首先看下面这个代码，这个Base占用多少字节呢？

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

通过在32位平台下验证我们发现结果是8。

查看监视窗口我们发现这里有一个_vfptr，这个叫做虚表指针，存的是虚函数表的地址。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

如果被继承之后会怎么样呢？我们再接着验证。

class Base
{
public:
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;
};
class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};
int main()
{
	Base b;//8
	cout << sizeof(Base) << endl;
	Derive d;//12
	cout << sizeof(Derive) << endl;
	return 0;
}

这里Base的大小是8（一个虚表指针4，一个成员变量_b是4，4+4=8）
Derive的大小是12（一个虚表指针4，一个继承下来的成员变量_b是4，一个成员变量_d是4，4+4+4=12）

这里的Fun1和Fun2是虚函数，会被继承到虚函数表里，但是Fun1在子类中完成了重写，所以首先d里面有一个虚表指针，另外Fun3也被继承下来了，但是因为不是虚函数，所以不会放在虚表中，就是普通成员函数的继承。b中的_b被继承下来，另外d自己还有一个成员变量_d。

派生类虚表的生成：

1. 先把父类的虚表拷贝过来
2. 判断有没有重写的情况，如果有直接对某函数覆盖
3. 看子类中还有没有虚函数，如果有就补在子类虚函数表的后面，有几个就补几个

虚函数存在哪的？虚表存在哪的？

虚函数其实和普通的函数一样，都是成员函数，都存在代码段的，只是虚函数的地址会被保存在虚表中。另外对象中存的不是虚表，而是虚表指针。
那么虚表又存在哪里呢？
我们可以写一段代码进行验证：

int main()
{
	Base base;
	int a;//栈
	int* b = new int;//堆
	static int c;//静态区
	char* d = "abcd";//代码段

	cout << &a << endl;
	cout << b << endl;
	cout << &c << endl;
	cout << (void*)d << endl;

	cout << (void*)(*(int*)&base) << endl;
	system("pause");
	return 0;
}

首先我们分析堆栈是不可能的，因为虚表指针在程序编译好的时候是不会改变的，栈上存放的是局部变量，出了作用域会被销毁，因此排除栈。堆是进行动态开辟的区域，因此排除堆。静态区的数据要不就是静态数据要不就是全局数据，因此分许出来放在代码段最为合适。并且通过代码验证，发现虚表指针的地址和代码段的d的地址非常接近，因此可以断定在代码段。

多态的原理

再返回看我们写的买票函数

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

普通调用：静态联编（编译时决议）
多态调用：动态联编（运行时决议）

多态是一种动态联编，它是在程序运行起来的时候，调用对应函数时去虚表里面查找的，找到地址之后再去call调用它。

我们通过汇编语言再来了解一下多态调用。

六、单继承和多继承关系的虚函数表

单继承中的虚函数表

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;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}

根据我们了解的多态的知识，我们分析上面的代码可以得出，Derive里会将func1重写，然后将Base里的func2继承下来，另外再补上自己的func3和func4。我们调用监视窗口进行查看：

咦？我们发现只有重写的func1和继承下来的func2，而没有Derive里面自己的func3和func4，这是为什么呢？这是因为编译器对它进行了优化。那么我们可以自己写一段代码来打印Derive的虚函数表。

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

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

typedef void(*VFUNC)();//定义一个函数指针VFUNC

void PrintVTable(VFUNC* table)
{
	cout << "虚表" << table << endl;
	for (int i = 0; table[i] != nullptr; i++)//虚表的最后一个元素是nullptr
	{
		printf("虚函数%d : [0x%p]->", i, table[i]);
		table[i]();
	}
}

int main()
{
	Derive d;
	//d的前四个字节是虚表指针，拿到虚表指针之后调用打印虚表函数
	PrintVTable((VFUNC*)(*(int*)&d));
	return 0;
}

发现d的虚表有如下几个虚函数：

多继承中的虚函数表

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

调用监视窗口进行查看我们发现Derive里的两个func1都被覆盖了，但是Derive里的func3去哪里了呢？

我们写代码来打印虚函数表，进行验证：（这里需要注意的是，d中的虚函数表有两个，一个是从Base1继承下来的，一个是从Base2继承下来的，编译器会根据继承的顺序进行排列）

typedef void(*VFUNC)();
void PrintVTable(VFUNC* table)
{
	cout << "虚函数表:" << table << endl;
	for (int i = 0; table[i] != nullptr; i++)
	{
		printf("虚函数%d : [0x%p]->", i, table[i]);
		table[i]();
	}
	cout << endl;
}
int main()
{
	Base1 b1;
	Base2 b2;
	Derive d;
	
	//打印d中继承的Base1的虚函数表
	PrintVTable((VFUNC*)(*(int*)&d));
	
	//打印d中继承的Base2的虚函数表
	PrintVTable((VFUNC*)(*(int*)((char*)&d + sizeof(Base1))));
	return 0;
}

这里打印Base1的虚函数表和单继承的原理一样，那么打印Base2的虚函数表就需要谈一谈了：

1. 将d的地址强转为char*，一次取一个字节
2. 再加上sizeof(Base1)，就是一次加一个字节，加Base1的大小，这里就跳过了Base1
3. 因为编译器是按照继承的顺序来进行存放的，所以跳过了Base1此时指向的就是Base2的虚函数表的首地址
4. 拿到首地址之后在强转为int*然后再解引用，取到Base2的前四个字节，这个值就是指向虚表的指针
5. 再强转成VFUNC*，因为虚表就是一个存VFUNC类型(虚函数指针类型)的数组。
6. 虚表指针传递给PrintVTable进行打印虚表

打印结果如下：

我们发现子类中自己的虚函数会保存在第一个继承的类里的虚函数表里。

菱形继承、菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不探究啦 |ू･ω･` )，一般我们也不需要研究清楚，因为实际中很少用。

七、多态常见的面试问题来一波

1. 什么是多态？
2. 什么是重载、重写(覆盖)、重定义(隐藏)？
3. 多态的实现原理？
   答：虚函数表
4. inline函数可以是虚函数吗？
   答：不能，因为inline函数没有地址，无法把地址放到虚函数表中。
5. 静态成员可以是虚函数吗？
   答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
6. 构造函数可以是虚函数吗？
   答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。如果是虚函数的话会构成多态，多态是一种运行时编译，所不可以。
7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？
   答：可以，并且最好把基类的析构函数定义成虚函数。父类的指针指向一个子类的对象时，释放时就应该去调用子类的析构函数，这是一种多态行为。
8. 对象访问普通函数快还是虚函数更快？
   答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
9. 虚函数表是在什么阶段生成的，存在哪的？
   答：虚函数是在编译阶段就生成的，一般情况下存在代码段的。
10. 什么是抽象类？抽象类的作用？
    答：抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。