多态的核心是虚函数，本文从虚函数出发，根据原理慢慢推进得到结论，进而理解多态
1.虚函数
先看一下下面的代码，想想什么导致了这个结果
cpp
#include <iostream>
using namespace std;
class A
{
public:
virtual void test()
{
cout << "A" << endl;;
}
};
class B : public A
{
public:
void test()
{
cout << "B" << endl;;
}
};
class C : public B
{
public:
void test()
{
cout << "C" << endl;;
}
};
void Test(A& r)
{
r.test();
}
int main()
{
A a;
B b;
C c;
Test(a);
Test(b);
Test(c);
return 0;
}结果是
如果我们去掉A里面的virtual呢？
我们可以看到前后两次结果不同，为什么呢？函数形参为什么是以A&来接收的，调用时为什么还有区别呢？这就需要接触虚函数了。
（1）虚函数和虚函数表
当我们在父类声明了一个虚函数后，这个函数就被存在常量区了，同时在这个类里又多了一个新的隐藏成员，叫虚函数表（这个成员要算在整个类的大小里面）。 这个虚函数表就是专门存虚函数的地址的（本质是函数指针数组，根据不同机器指针大小也不同 ）。对于父类而言，无论创建多少对象，它们都共用一个虚函数表（即对于同一种类，函数都是一样的）。这里要分清：虚函数是存在常量区的而不存在类里，类中存的是虚函数表。
（2）重写
虚函数有什么用呢？**当子类实现一个和父类虚函数函数名、参数、返回值完全一样的函数时，就叫做重写。重写是一种特殊的隐藏，是在多态中的一种语法，而隐藏只要求函数名相同，是继承中的语法。**重写的意义在于子类也有一个新的虚函数表，虽然函数前没有加声明virtual（父类前必须加），当子类显式写了这个函数，就会存到常量区，虚函数表存函数的地址（第一句指令的地址）。对于这个子类，无论创建多少个对象，它们都使用同一个针对子类的虚函数表。如果说有多个虚函数而子类没有重写，那个没有重写的函数就使用父类的对应的函数（反正没区别）。
（3）对多态的理解
到这里，我们对虚函数表、虚函数和重写有了一定了解，实际就是在最初的父类的函数前加上virtual，让该函数进入虚函数表，子类重写会让虚函数表存的函数不同，在调用的时候明明是调用的同一个函数，但得到的结果是针对每一种类不同的。这就叫多态，即多种形态，针对不同的类有不同的表现形态。
（4）对多态调用方式的理解
函数形参为什么是以A&来接收的？
我们进一步关注Test(A& r)这个函数，前面我们讲**了赋值兼容转换，因此当B和C传进去的时候，r都会指向子类中的父类部分，这里相当于给它们的父类部分取别名。**也就是说，r无论接收的是A还是B还是C，最终都会被切割成A的模样（A中也有虚函数表），但是内容是不是都一样呢？
很明显，虚函数表的作用就凸显出来了，A、B、C都有一个虚函数表，在B、C切割成A后，虚函数表被保留了下来，当我们用r去调用虚函数时，编译器会默认去虚函数表找到对应的函数 （三种虚函数表的函数在函数名、参数、返回值上都相同，但存的函数地址不同），根据不同的函数地址就能找到不同的函数实现，这也是重写的意义所在。
至此，我们应该能够理解前面所说虚函数、虚函数表、重写存在的意义了，它们的出现都最终服务于实现一件事------多态，即根据不同类，在调用同一函数时体现出不同状态。
（5）是否有其它调用方式？
事实上，使用A&调用本质就是利用了赋值兼容转换，将多个子类都切割成父类的形式，再根据它们虚函数表的值的差异，调用不同的同名函数，体现出类与类之间的区别。 很明显，除了引用，指针也适合，但赋值呢？赋值不是也遵循赋值兼容转换吗？
从实验上看是不行的，但也好理解。r都已经完全变成A类型了，再去调用B或C的成员就不太说得过去了。你可以将这里理解成一种特殊处理，支不支持都说得过去，但从形式上来说不支持更合理。
（6）多态的条件
很多课程都喜欢先说条件再将原因，而如果我们慢慢推进，到这里自然就理解了。
多态需满足条件： 父类函数（想和子类形成差异的第一个函数就叫父类函数）写virtual（父类如果不写virtual而子类写virtual，那第一个写virtual的才叫父类，你可以将virtual当作一个多态开始的标志 ），后续的所有子类写不写virtual无所谓；子类覆盖/重写父类的虚函数；调用时使用父类的指针或引用，特别注意不能用赋值。
2.协变
上面说过要重写函数，必须保证函数的函数名、参数、返回值相同。但有唯一一个例外可以在返回值不同时能构成重写，就是协变（基本不用），即返回值可以是父子类的引用或指针。
下面这段代码是能跑过的
cpp
#include <iostream>
using namespace std;
class A
{
public:
virtual A& test()
{
cout << "A" << endl;;
return *this;
}
};
class B : public A
{
public:
B& test()
{
cout << "B" << endl;;
return *this;
}
};
void Test(A& r)
{
r.test();
}
int main()
{
A a;
B b;
Test(a);
Test(b);
return 0;
}
注意，返回值可以加const，返回值也可以是其它类，但必须是父子关系
cpp
#include <iostream>
using namespace std;
class C
{};
class D : public C
{};
class A
{
public:
virtual const C* test()
{
cout << "A" << endl;
C* c = new C;
return c;
}
};
class B : public A
{
public:
const D* test()
{
cout << "B" << endl;
D* d = new D;
return d;
}
};
void Test(A& r)
{
r.test();
}
int main()
{
A a;
B b;
Test(a);
Test(b);
return 0;
}
注意父子关系顺序不能反，父类返回值对应父类的虚函数
协变几乎不用，了解即可。我们大部分情况还是要保证函数名、参数、返回值相同，讨论的时候也是跳过这个特殊情况的。
3.析构函数的重写
理解析构函数的重写可以加深我们对析构函数的理解，顺便能够解释为什么所有的析构函数都会被处理成destructor()
cpp
#include <iostream>
using namespace std;
class A
{
public:
~A()
{
cout << "A" << endl;
}
};
class B : public A
{
public:
~B()
{
cout << "B" << endl;
delete p;
}
int* p;
};
int main()
{
A* a = new B;
delete a;
return 0;
}这段代码会导致内存泄漏，因为当delete a的时候，会根据a的类型去调用析构函数，这里就只会去调用A的析构函数
联系到上面的重写，很快我们就会想到使用virtual修饰父类的析构函数，让析构函数进入虚函数表。但是很明显父类和子类的类名是不可能相同的，所以类的析构函数做了特殊处理：即都重命名为~destructor()，这样就符合了虚函数的要求
我们可以看到，这里根据虚函数表就能成功调到子的析构函数了，同时对于所有继承而言，子的析构调用完成之后都会逐级向上调用父的析构函数