C++虚表（V-Table）解析

　　C++中的虚函数的作用主要是实现了多态，本人通过代码验证的方式了解虚表的结构及在多种继承方式下通过虚表访问子类函数。验证结果如下：

　　1）无虚函数覆盖的一般继承：可以通过子类的虚表访问父类的函数

　　2）虚函数重载父类的虚表：子类重载的虚函数会覆盖父类的函数

　　3）多重继承无重载的虚表：多重继承子类的虚表就像一张二维表，可以像遍历二维数组一样访问所有父类函数

　　4）多重继承有重载的虚表：所有父类被重载的虚函数都会被覆盖

　　5）父类指针访问子类自己的虚函数

　　6）公有继承访问父类非公有虚函数

 #include "stdafx.h"
 #include <iostream>
 #include <Windows.h>
 using namespace std;
 // 基类
 class Base
 {
 public:
     virtual void Fun1()
     {
         cout << "Base::Fun1" << endl;
     }
     virtual void Fun2()
     {
         cout << "Base::Fun2" << endl;
     }
     virtual void Fun3()
     {
         cout << "Base::Fun3" << endl;
     }

 private:

 };

 // 无重载继承类
 class Derive :Base
 {
 public:
     virtual void DeriveFun1()
     {
         cout << "Derive::Fun1" << endl;
     }
     virtual void DeriveFun2()
     {
         cout << "Derive::Fun2" << endl;
     }
     virtual void DeriveFun3()
     {
         cout << "Derive::Fun3" << endl;
     }
 };

 // 重载继承类
 class Override :public Base
 {
 public:
     virtual void Fun1()
     {
         cout << "Override::Fun1" << endl;
     }
     virtual void OverrideFun2()
     {
         cout << "Override::Fun2" << endl;
     }
     virtual void OverrideFun3()
     {
         cout << "Override::Fun3" << endl;
     }
 };

 // 多重继承无重载
 class Base1
 {
 public :
     virtual void Fun1()
     {
         cout << "Base1::Fun1" << endl;
     }
     virtual void Fun2()
     {
         cout << "Base1::Fun2" << endl;
     }
     virtual void Fun3()
     {
         cout << "Base1::Fun3" << endl;
     }
 };
 class Base2
 {
 public:
     virtual void Fun1()
     {
         cout << "Base2::Fun1" << endl;
     }
     virtual void Fun2()
     {
         cout << "Base2::Fun2" << endl;
     }
     virtual void Fun3()
     {
         cout << "Base2::Fun3" << endl;
     }
 };
 class MultipleDerive :public Base, public Base1, public Base2
 {
 public:
     virtual void MultipleDeriveFun1()
     {
         cout << "MultipleDerive::Fun1" << endl;
     }
     virtual void MultipleDeriveFun2()
     {
         cout << "MultipleDerive::Fun2" << endl;
     }
     virtual void MultipleDeriveFun3()
     {
         cout << "MultipleDerive::Fun3" << endl;
     }
 };
 // 多重继承重载
 class MultipleDeriveOverride :public Base, public Base1, public Base2
 {
 public:
     virtual void Fun1()
     {
         cout << "MultipleDerive::Fun1" << endl;
     }
     virtual void MultipleDeriveFun2()
     {
         cout << "MultipleDerive::Fun2" << endl;
     }
     virtual void MultipleDeriveFun3()
     {
         cout << "MultipleDerive::Fun3" << endl;
     }
 };
 // 公有继承访问父类非公有虚函数
 class Base3
 {
 private:
     virtual void Fun1()
     {
         cout << "Base3::Fun1" << endl;
     }

 };

 class Derive1 : public Base3
 {

 };
 typedef void(*Fun)(void);
 // 验证虚函数表
 void Sub_1();
 // 验证无虚函数覆盖的一般继承
 void Sub_2();
 // 验证虚函数重载父类的虚表
 void Sub_3();
 // 验证多重继承无重载的虚表
 void Sub_4();
 // 验证多重继承有重载的虚表
 void Sub_5();
 // 验证父类指针访问子类自己的虚函数??
 void Sub_6();
 // 验证公有继承访问父类非公有虚函数
 void Sub_7();

 int main()
 {
     //Sub_1();
     //Sub_2();
     //Sub_3();
     //Sub_4();
     //Sub_5();
     //Sub_6();
     Sub_7();
     return ;
 }
 void Sub_7()
 {
     Derive1 v1;
     Fun  pFun = (Fun)*((int*)*(int*)(&v1) + );
     pFun();
 }
 void Sub_6()
 {
     Base *v1 = new Override();
     // 多态
     v1->Fun1();
     Fun pFun = NULL;
     //pFun = (Fun)*((Override*)(v1));
     pFun();
 }
 void Sub_5()
 {
     MultipleDeriveOverride v1;
     Fun pFun = NULL;
     Base *b = &v1;
     Base1 *b1 = &v1;
     Base2 *b2 = &v1;
     b->Fun1();
     b->Fun2();
     b->Fun3();
     b1->Fun1();
     b1->Fun2();
     b1->Fun3();
     b2->Fun1();
     b2->Fun2();
     b2->Fun3();
 }
 void Sub_4()
 {
     MultipleDerive v1;
     Fun pFun = NULL;
     int** pVtable = (int**)&v1;
     // Base的第一函数
     pFun = (Fun)pVtable[][];
     pFun();
     // Base的第二函数
     pFun = (Fun)pVtable[][];
     pFun();
     // Base的第三函数
     pFun = (Fun)pVtable[][];
     pFun();
     // 继承类的第一函数
     pFun = (Fun)pVtable[][];
     pFun();
     // 继承类的第二函数
     pFun = (Fun)pVtable[][];
     pFun();
     // 继承类的第三函数
     pFun = (Fun)pVtable[][];
     pFun();
     // Base1的第一函数
     pFun = (Fun)pVtable[][];
     pFun();
     // Base1的第二函数
     pFun = (Fun)pVtable[][];
     pFun();
     // Base1的第三函数
     pFun = (Fun)pVtable[][];
     pFun();
     // Base2的第一函数
     pFun = (Fun)pVtable[][];
     pFun();
     // Base2的第二函数
     pFun = (Fun)pVtable[][];
     pFun();
     // Base2的第三函数
     pFun = (Fun)pVtable[][];
     pFun();
 }
 void Sub_3()
 {
     Override v1;
     Fun pFun = NULL;
     // 运行重载第一函数
     pFun = (Fun)*((int*)*(int*)(&v1));
     pFun();
     // 运行父类第二函数
     pFun = (Fun)*((int*)*(int*)(&v1)+);
     pFun();
     // 运行父类第三函数
     pFun = (Fun)*((int*)*(int*)(&v1)+);
     pFun();
     // 运行重载第二函数
     pFun = (Fun)*((int*)*(int*)(&v1) + );
     pFun();
     // 运行重载第三函数
     pFun = (Fun)*((int*)*(int*)(&v1) + );
     pFun();
 }
 void Sub_2()
 {
     Derive v1;
     Fun pFun = NULL;
     // 运行父类第一函数
     pFun = (Fun)*((int*)*(int*)(&v1));
     pFun();
     // 运行父类第二函数
     pFun = (Fun)*((int*)*(int*)(&v1) + );
     pFun();
     // 运行父类第三函数
     pFun = (Fun)*((int*)*(int*)(&v1) + );
     pFun();
     // 运行子类第一函数
     pFun = (Fun)*((int*)*(int*)(&v1) + );
     pFun();
     // 运行子类第二函数
     pFun = (Fun)*((int*)*(int*)(&v1) + );
     pFun();
     // 运行子类第三函数
     pFun = (Fun)*((int*)*(int*)(&v1) + );
     pFun();
 }
 void Sub_1()
 {
     Base v1;
     Fun pFun = NULL;
     cout << "虚函数表地址：" << (int*)(&v1) << endl;
     cout << "虚函数表第一函数地址：" << (int*)*(int*)(&v1) << endl;
     // 运行第一个函数
     pFun = (Fun)*((int*)*(int*)(&v1));
     pFun();
     // 运行第二个函数
     pFun = (Fun)*((int*)*(int*)(&v1) + );
     pFun();
     // 运行第三个函数
     pFun = (Fun)*((int*)*(int*)(&v1) + );
     pFun();
     // 虚函数表的结束
     cout << ((&v1) + ) << endl;
 }