C++中多态是通过虚函数实现，所以我们先了解虚函数。
虚函数
在函数前面加上virtual关键字后，函数变成虚函数。
如果通过对象调用，虚函数和普通函数没有区别。写代码验证，反汇编后代码都是E8 call，调用方式是直接调用，没有区别。
class MyClazz
{
public:
void fun1() {
printf("fun1...\n");
}
virtual void fun2() {
printf("fun2...\n");
}
};
int main()
{
MyClazz myClazz;
myClazz.fun1();
myClazz.fun2();
}
反汇编代码：
18: MyClazz myClazz;
006319BF 8D 4D F4 lea ecx,[ebp-0Ch]
006319C2 E8 FF F8 FF FF call 006312C6
19: myClazz.fun1();
006319C7 8D 4D F4 lea ecx,[ebp-0Ch]
006319CA E8 D8 F9 FF FF call 006313A7
20: myClazz.fun2();
006319CF 8D 4D F4 lea ecx,[ebp-0Ch]
006319D2 E8 82 F7 FF FF call 00631159
如果通过指针来调用，调用虚函数时使用间接调用：
class MyClazz
{
public:
void fun1() {
printf("fun1...\n");
}
virtual void fun2() {
printf("fun2...\n");
}
};
int main()
{
MyClazz myClazz;
MyClazz* ptr = &myClazz;
ptr->fun1();
ptr->fun2();
}
18: MyClazz myClazz;
004919BF 8D 4D F4 lea ecx,[ebp-0Ch]
004919C2 E8 FF F8 FF FF call 004912C6
19: MyClazz* ptr = &myClazz;
004919C7 8D 45 F4 lea eax,[ebp-0Ch]
004919CA 89 45 E8 mov dword ptr [ebp-18h],eax
20: ptr->fun1();
004919CD 8B 4D E8 mov ecx,dword ptr [ebp-18h]
004919D0 E8 D2 F9 FF FF call 004913A7
21: ptr->fun2();
004919D5 8B 45 E8 mov eax,dword ptr [ebp-18h]
004919D8 8B 10 mov edx,dword ptr [eax]
004919DA 8B F4 mov esi,esp
004919DC 8B 4D E8 mov ecx,dword ptr [ebp-18h]
004919DF 8B 02 mov eax,dword ptr [edx]
004919E1 FF D0 call eax
类的大小
如果类中有虚函数的时候，对象大小会增加4个字节。多出来的4字节是一个地址，指向所有虚函数的地址，这个地址叫虚函数表，虚函数表中存的值是函数地址。
代码验证：
class MyClazz
{
public:
int x;
int y;
MyClazz() {
x = 1;
y = 2;
}
virtual void VirtualFun() {
printf("VirtualFun...\n");
}
};
int main()
{
MyClazz myClazz;
MyClazz* ptr = &myClazz;
ptr->VirtualFun();
}
查看ptr数据，最前面4个字节0xd57b34是多出来的虚函数表。
查看0xd57b34虚函数表数据，虚函数表中存储的是函数地址。
程序执行的时候，编译器按照序号寻找虚函数，调用虚函数：
class MyClazz
{
public:
int x;
int y;
MyClazz() {
x = 1;
y = 2;
}
virtual void VirtualFun1() {
printf("VirtualFun1...\n");
}
virtual void VirtualFun2() {
printf("VirtualFun2...\n");
}
};
int main()
{
MyClazz myClazz;
MyClazz* ptr = &myClazz;
printf("虚函数表地址为：%x\n", *(int*)&myClazz);
typedef void(*pFunction)(void);
//调用第1个虚函数
pFunction pFn;
pFn = (pFunction) * ((int*)(*(int*)&myClazz) + 0);
pFn();
//调用第2个虚函数
pFunction pFn2;
pFn2 = (pFunction) * ((int*)(*(int*)&myClazz) + 1);
pFn2();
}
终端打印：
虚函数表地址为：eb7b34
VirtualFun1...
VirtualFun2...
总结虚函数特性：
1、虚函数表的数量是编译时候确定的。
2、单继承时，子类会生成1个虚函数表，子类会继承基类虚函数。如果函数原型相同，子类虚函数会覆盖基类虚函数。
3、多继承时会产生多个虚函数表。同样会覆盖基类虚函数。
4、多重继承，子类会继承所有基类虚函数，如果子类虚函数和基类虚函数原型相同，会覆盖基类虚函数。
5、如果有继承多个基类，子类会有多个虚函数表。
动态绑定
1、调用的代码和真正的函数关联到一起的过程叫绑定。
2、如果编译的时候能确定绑定，叫做编译期绑定，或者叫前期绑定。类的普通的成员和函数编译之后，地址已经确定，是编译器绑定。
3、如果编译的时候无法确定，叫做动态绑定，或者叫运行期绑定。虚函数在编译的时候无法确定。能够体现不同的行为，称为多态，动态绑定也叫多态。多态通过虚函数表来实现。
class Base
{
public:
int x;
public:
Base()
{
x = 1;
}
void Function_1()
{
printf("Base:Function_1...\n");
}
virtual void Function_2()
{
printf("Base:Function_2...virtual\n");
}
};
class Sub :public Base
{
public:
int x;
public:
Sub()
{
x = 2;
}
void Function_1()
{
printf("Sub:Function_1...\n");
}
virtual void Function_2()
{
printf("Sub:Function_2...virtual\n");
}
};
void TestBind(Base* pb)
{
int n = pb->x;
printf("%x\n", n);
pb->Function_1();
pb->Function_2();
/*
pb->Function_1();
8B 4D 08 mov ecx,dword ptr [ebp+8]
E8 AF E8 FF FF call 00E71406
pb->Function_2();
8B 45 08 mov eax,dword ptr [ebp+8]
8B 10 mov edx,dword ptr [eax]
8B F4 mov esi,esp
8B 4D 08 mov ecx,dword ptr [ebp+8]
8B 02 mov eax,dword ptr [edx]
FF D0 call eax
*/
}
int main(int argc, char* argv[])
{
/*
打印结果：
1
Base:Function_1...
Base:Function_2...virtual
*/
Base base;
TestBind(&base);
/*
打印结果：
1
Base:Function_1...
Sub:Function_2...virtual
*/
Sub sub;
TestBind(&sub);
return 0;
}