【C++进阶：多态】
本节涉及到的所有测试代码见以下链接，欢迎参考指正：
practice: 课程代码练习 - Gitee.com
多态的概念及定义
概念
例一：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。例二：还有就是之前支付宝推出的扫码领红包，为什么有人扫的红包8块、10块...，而有人扫的红包都是1毛，5毛....。其实这背后也是一个多态行为。支付宝首先会分析你的账户数据，比如你是新用户或没有经常支付宝支付，那么你需要被鼓励使用支付宝，那么就你扫码金额 = random()%99；比如你经常使用支付宝支付，那么就不需要太鼓励你去使用支付宝，那么就你扫码金额 =random()%1；总结一下：同样是扫码动作，不同的用户扫得到的不一样的红包，这也是一种多态行为。
定义及实现
构成多态的条件
虚函数：
被virtual修饰的类成员函数称为虚函数【注意：这里的虚函数和继承章节的菱形虚拟继承没有任何关系，二者只是共用了一个关键字virtual】
class Person
{
public:
virtual void BuyTicket() { cout << "买票-全价" << endl;}
};虚函数的重写（或覆盖）：
派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写（或覆盖）了基类的虚函数。
class Person //基类
{
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person //派生类
{
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
/*void BuyTicket() { cout << "买票-半价" << endl; }*/
/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因
为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议
这样使用*/
};
void Func(Person& p)//父类的指针或引用调用虚函数
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Func(ps);
Func(st);
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;}
};注意：虚函数就是为重写而生，没有重写的概念就没有虚函数的概念，而重写就是为多态而生，没有重写，就不满足实现多态的条件，自然没有多态。
实现多态必须严格遵守两个条件，通过以下例子加深理解：
1.基类函数不是虚函数，无论派生类函数是否是虚函数，都不能构成重写
2.基类函数是虚函数，无论派生类函数是否有virtual修饰，它都是悬殊，可以构成重写 
3. 基类和派生类虚函数返回值不同，分别为具有父子类关系的父类子类的指针或引用，重写特例（谐变）
（1）父类引用调，可以实现
（2）父类指针调，也可以实现
4.调用虚函数的对象不是父类的指针或引用，虽然虚函数完成重写，也不能构成多态
重载、覆盖(重写)、隐藏(重定义)的对比
真题试炼：
1.以下程序的结果是（）：
A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确
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;//如果是A* p = new B，运行结果也是一样的，它虽然是一个A*的指针，但是实际指向的是一个B类型的对象，因此这里看的是实际指向的物理空间存的是谁 p->test(); return 0; }分析图示如下：
C++11 override 和 fifinal
抽象类
概念
接口继承和实现继承：
多态的原理
虚函数表
先来看一道经典面试题目：
显然，不是简单的内存对齐问题，除了int类型和char类型的成员变量，一定还存有其他的东西，调出监视窗口，发现除了_b和_c还存了一个指针_vfptr，这个指针叫虚函数表指针(v代表virtual，f代表function)，指针指向一个虚函数表
一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表，虚表实际上可以看做是一个虚函数指针数组，那么派生类中这个表放了些什么呢？我们接着往下分析。
总结：
1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，包括基类中的虚表指针，另一部分是自己的成员。2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一nullptr。
派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数c.派生类自己 新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。注意：这里还有一个很容易混淆的问题：虚函数存在哪的？虚表存在哪的？答：虚函数存在 虚表，虚表存在对象中。注意这样的回答的错的。虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是 他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的 呢？实际我们去验证一下会发现vs下是存在代码段的，可以自行验证。
多态底层原理
分析：
观察上图我们看到，people是Mike对象时，BuyTicket在Mike的虚表中找到虚函数是Person::BuyTicket;people是Johnson对象时，BuyTicket在Johnson的虚表中找到虚函数是Student::BuyTicket, 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？ 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。（1）不满足多态时，就是普通的函数调用
（2）满足多态时，就要用多态调用的方法
反思：到这里，我们对多态的底层有了一定的了解，那么反过来再看实现多态的条件，为什么一定要基类的指针或引用来调用呢？基类对象为什么不行，这就要基于下图：
子类的指针或引用可以直接赋值给父类的指针或引用，这个时候，虽然有切片行为的发生，但这个指针或者引用指向的还是原来的子类对象，使用的虚表也还是原来子类对象的虚表，但如果是子类对象直接赋值给父类对象，就要进行切片赋值，而虚表指针是不能拷贝的【如果虚表可以拷贝，就乱套了，给你一个父类对象，你不知道里面是父类的虚表还是子类赋值后子类的虚表】，此时这个父类对象的虚表只能是父类的虚表，无法实现不同对象的不同行为，因此不能实现多态行为。
注意：同类对象共用同一个虚表
单继承和多继承关系的虚函数表
单继承中的虚函数表
先来观察下面代码运行的监视窗口以及内存窗口：
观察以上代码的监视窗口发现，子类对象d中的虚表指针指向的虚表中竟然没有虚函数指针func3()和func4()，这不符合只要是虚函数就进虚表的规则，我们都知道，监视窗口有时候并不能反应真实情况【事实上这里确实可以算是vs编译器的一个bug】，而内存中的内容才是真实的，调用内存窗口观察子类虚表可以发现，funn1()和func2()的地址后面还有两个有效的内容可能就是监视窗口中隐藏掉的func3()和func4()的地址，究竟我们的推测是不是正确的？可以通过打印虚表的方式来验证。
打印虚表
依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数，因此来写一个打印虚表的函数 ，代码如下：
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;
};
//打印虚表，需要传一个虚表指针，我们知道虚表本质上是一个数组，数组的类型是虚函数指针
//这里的函数指针为 void (*)(),由于涉及到函数指针，比较复杂，因此这里可以重命名简化一下
typedef void (*VF_Ptr)();//函数指针的重命名比较特殊
void VFTablePrint(VF_Ptr vft[])
{
//根据数组传参的特点，这里的vft实际上是虚表首元素的地址，即vtr类型是第一个虚函数指针的地址，即VF_Ptr*
//写一个循环来找到虚表中所有虚函数的地址，有了函数地址自然可以找到相应的函数
for (int i = 0; vft[i] != nullptr; i++)//VS编译器下，会将数组最后一个元素后面的内容置为nullptr，gcc环境下就不能这么写了
{
printf("[%d] :%p", i, vft[i]);
VF_Ptr f = vft[i];
f();
}
cout << endl;
}
int main()
{
Base b;
Derive d;
VFTablePrint((VF_Ptr*)(*(int*)&b));
//VFTablePrint((VF_Ptr*)(*(int*)&d));
return 0;
}打印虚表的逻辑相信都不难理解，这里真正有困难的是传参数的问题，我们现在有的是整个对象的地址如何能把这个对象的虚表指针找到呢，来看下面的分析：
按照上面的思路顺着分析，我们发现其实也是可以理解的，唯一存在的问题就是存在平台局限问题，下面还有一种分析方法就没有平台限制的问题，但可能不好理解，大家根据情况能理解一种就好了。
关于虚表的一些小问题：
1.虚表是什么阶段生成的？ -- 编译
2.对象中虚表指针什么时候初始化的？ -- 构造函数的初始化列表
也就是覆盖/重写，是发生在构造阶段，在初始化列表，会重写符合条件的虚函数，但是虚表早在编译阶段就生成了。
3.虚表存在哪里？--常量区【代码段】简单验证一下：
多继承中的虚函数表
在有两个父类的多继承情况，派生类对象中有两张虚表，也就是只要满足多态，虚函数在两张虚表中都会进行重写，如下：
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;
};
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);
VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
PrintVTable(vTableb1);
PrintVTable(vTableb2);
return 0;
}
观察上图也可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。同时发现，在两张虚表中都重写了的func1()函数地址不一样，这实际上是在第二张虚表中重写时进行了层层封装，但最终底层调用的都是同一个func1()，具体内容需要通过汇编代码去理解，这里不用过于纠结。
菱形虚拟继承的中的虚表和虚基表
【简单了解一下即可，校招考不到很深，实际工作当中也不会用到很多，浅尝辄止，别深入研究！！！】
class A
{
public:
virtual void func1()
{}
public:
int _a;
};
class B : virtual public A
{
public:
virtual void func1()
{}
virtual void func2()
{}
public:
int _b;
};
class C : virtual public A
{
public:
virtual void func1()
{}
virtual void func3()
{}
public:
int _c;
};
class D : public B, public C
{
public:
virtual void func1()
{}
public:
int _d;
};
int main()
{
D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
return 0;
}分析d对象的内存空间，结合虚拟继承的知识，有如下：
再说一遍，看不懂也不重要，不是重点！！！
常考问答题汇总
根据本节的总结，可以自行完善答案，这里不再赘述！
1. 什么是多态？答：参考本节总结内容2. 什么是重载、重写(覆盖)、重定义(隐藏)？答：参考本节总结内容3. 多态的实现原理？答：参考本节总结内容4. inline函数可以是虚函数吗？答：可以，Inline是给编译器提的一个建议，编译器并不一定会采纳，因此，不过编译器就忽略inline属性，这个函数就不再是inline，因为虚函数要放到虚表中去。5. 静态成员可以是虚函数吗？答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。6. 构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析构函数定义成虚函数。参考本节总结内容8. 对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。9. 虚函数表是在什么阶段生成的，存在哪的？答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。10. C++菱形继承的问题？虚继承的原理？答：参考继承那一节的总结。注意这里不要把虚函数表和虚基表搞混了。11. 什么是抽象类？抽象类的作用？答：参考（3.抽象类）。抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。
本节涉及到的所有测试代码见以下链接，欢迎参考指正：
practice: 课程代码练习 - Gitee.com