C++ 运用虚指针访问虚函数表，并使用函数指针调用虚函数，可以任意访问虚函数！！！！！！撸了两天！！！！！，附代码

通过虚指针访问虚函数表并且调用虚函数表内函数实现多态，并能够任意访问虚函数。-----附代码

多态的实现就是通过虚函数表和继承来实现

一、多态的实现

现在有两个类
1.父类如下

class base
{
public:
   virtual void P()
    {
        cout<<"PPPPP of base"<<endl;
    }
   virtual void P1()
     {
         cout<<"PPPPPP111111 of base"<<endl;
     }
    void P2()
      {
          cout<<"PPPPP2222222 of base"<<endl;
      }

};

2.子类如下：

```cpp
class derived:public base
{
public:
    int k;
    void P()
    {
        cout<<"dervied P"<<endl;
    }
    void P1()
    {
             cout<<"PPPPP1111 of derievd"<<endl;
    }
    void P2()
      {
          cout<<"PPPPP11111111 of derived"<<endl;
      }
    static void print_1()
    {
        cout<<"printttt"<<endl;
    }
};

在父类中定义了三个虚函数：
P(),P1(),P2(),子类中也对该函数进行重写
之后通过定义子类对象d，并将其付给父类指针b，来实现多态,定义如下：
derived *d = new derived;
base* b = d;
 然后通过 b->P();来调用函数P() 输出结果如：

该父类指针调用子类的函数

二、通过虚函数表访问虚函数完成多态

1.多态的实现是通过虚函数表来完成，我们对类base 进行测量，base中包含三个虚函数，函数是不占内存大小，但通过sizeof(b)。
1).....在32位编译器中，其中b是base的实例化对象，发现base在内存4个字节。
2)......使用64位编译器则占8个字节。此处不贴图可以自己实验。
因此我们可以认定其内部包含一个指针，也就是虚函数指针。该指针指向虚函数表，我们现在通过该指针来访问虚函数表。

补充说明：经过这几天的尝试对于一个指针类型的对象，如上述的derived *d ，其
中derived中包含三个对父类的虚函数进行重写，此外包含一个整型变量K，因此
构造d时候，虚函数表在上侧，整型变量K在下侧，（对d进行测量其大小应该是
4/8 + 4，指针大小根据编译器的位数而定），我们执行 b=d ,(b+1)的操作指针会指
向K的地址因为b的类型是base该大小是4/8位，执行+1操作刚好跳过虚指针，但是如果
我们直接*(d+1)并不会取到K的内容，原因也是由于d被base修饰的原因，有时候直接无法通过编译。如下图

两者的地址是一致的

-----------------------------------------------------------------------------------------
回归正题，通过指针访问虚函数表
先给完整代码：

int** tmp = reinterpret_cast<int**>(b);
void(__stdcall *fun2)() = reinterpret_cast<void (__stdcall*)()>(**tmp);
fun2();

没错就这几行，原来是十几行，一行行删减最后就剩三行！！

先说一下__stdcall，估计不少人看了会蒙，我也是，我当时找了很久。
说一下作用，不写的话有的平台可以，你不写平台默认是__cdecl，这两个有啥区别，
就是一个是老版本的stdcall，一个是新版本默认的。他们都是在声明函数指针时候
使用，正常的声明函数指针void (*ptr)(),就是编译器会默认是
void(__cdecl *ptr)(),就这意思。

此外我的二维指针是int的，是因为我的编译器32位的，int 是4字节刚好32位，
64位的就自己换对于的关键字。

然后运行：
此时访问的是虚函数表里面的第一条，我这边虚函数表里面地址增量是30，看自己的编译器的增量，修改就可以访问任意一个虚函数了。
三、附录完成代码

#include<iostream>
using namespace  std;
class base
{
public:
   virtual void P()
    {
        cout<<"PPPPP of base"<<endl;
    }
   virtual void P1()
     {
         cout<<"PPPPP11111111 of base"<<endl;
     }
    void P2()
      {
          cout<<"PPPPP11111111 of base"<<endl;
      }

};
class derived:public base
{
public:
    int k;
    void P()
    {
        cout<<"dervied P"<<endl;
    }
    void P1()
    {
             cout<<"PPPPP1111 of derievd"<<endl;
    }
    void P2()
      {
          cout<<"PPPPP11111111 of base"<<endl;
      }
    static void print_1()
    {
        cout<<"printttt"<<endl;
    }
};


int main()
{

    derived *d = new derived;d->k=10011111;
    base *b = d;

    int** tmp = reinterpret_cast<int**>(b);

    void(__stdcall *fun2)() = reinterpret_cast<void (__stdcall*)()>(**tmp);
    fun2();

    return 0;

}