多态+多态对象模型

多态的实现条件
多态（与对象有关 到对象的虚表中找到）=动态联编+虚函数重写
动态联编（运行时决议）：指针/引用+虚函数
静态联编（编译时决议）与类型有关，像函数重载和通过对象名调用虚函数

1.定义一个父类的指针，如果这个指针指向父类，调用父类的虚函数，指针指向子类，调用子类的虚函数，这样可以使一个函数有不同的实现，即多态的体现。
2.根据模板的不同实例，实现不同类型的使用。

用一个例代码更好地理解

class A
{
public:
     virtual void f1()
    {
        cout<<"A::f1()"<<endl;
    }
     void f2()
     {
         cout<<"A::f2()"<<endl;
     }
      void f3()
     {
         cout<<"A::f3()"<<_a<<endl;
     }
private:
      int _a;

};
int main()
{
    A* p = NULL;
    //p->f1();(运行不通过，此处动态联编，寻找虚表)
    p->f2();//静态联编，不是虚函数，f2存在于代码段中，直接可以调用
    //p->f3();//（静态联编，this指针解引用后成空）
    return 0;
}

虚析构函数
这里我们先来清楚一个问题，为什么最好把父类的析构函数定义成虚函数呢？

#include<iostream>
using namespace std;
class A
{
public:
     virtual~A()
    {
        cout<<"~A()"<<endl;
    }
};
class B:public A
{
public:
    ~B()
    {
        cout<<"~B()"<<endl;
    }
};
int main()
{
    A* p=new B;
    delete p;
    return 0;
}

现象：给父类加上virtual后，会先析构子类的析构函数，再析构父类的析构函数。

分析:把父类的析构函数声明成虚函数，这将使所有派生类的析构函数自动成为虚函数。这样，如果想要显式地通过delete删除一个对象，delete的操作对象用了指向派生类对象的基类指针，则会调用基类的析构函数。

探索虚函数表
通过一块连续内存来存储虚函数的地址。

正如上图中监视显示，虚函数表_vfptr中存放着虚函数fun1和fun2的地址。
单继承有虚函数但是没有重写虚函数

通过监视窗口可以看到，父类中有一个虚函数，父类的实例化对象中有一个虚表指针和一个成员变量，然后子类中有一个函数，但不是虚函数，但为什么子类的成员变量里会有一个虚表指针呢？因为它是从父类里继承而来的。需要说明的是，这个函数指针，指向的内容是父类的虚函数。
单继承有虚函数有重写虚函数

class A
{
public:
    virtual void show()
    {
        cout<<"A show()"<<endl;
    }
public:
    int _a;
};
class B:public A
{
public:
    void show()
    {
        cout<<"B show()"<<endl;
    }
    void show1()
    {
        cout<<"B show()"<<endl;
    }
public:
    int _b;
};

int main()
{
    A a;
    B b;
    return 0;
}

通过和上面的继承虚函数相比，子类的虚函数表中的函数地址已经变成了子类的函数了。
探索单继承对象模型

class Base
{
public:
    virtual void fun1()
    {
        cout<<"Base::fun1"<<endl;
    }
    virtual void fun2()
    {
        cout<<"Base::fun2"<<endl;
    }
private:
    int a;
};
class Derive:public Base
{
public:
    virtual void fun1()
    {
        cout<<"Derive::fun1"<<endl;
    }
    virtual void fun3()
    {
        cout<<"Derive::fun3"<<endl;
    }
    virtual void fun4()
    {
        cout<<"Derive::fun4"<<endl;
    }
private:
    int b;
};
void Test()
{
    Base b1;
    Derive d1;
}

对于Derive类来说，我们预想的是，它的虚表里会有子类重写父类的fun1，父类的fun2，子类的fun3和fun4.

但是，通过监视窗口可知只有fun1()和fun2()。这里是因为编译器的问题所以没有显示出fun3和fun4。
所以接下来我们需要实现一个可以打印虚函数表的函数。

typedef void(*FUNC) ();
void PrintVTable(int* VTable)
{
    cout<<"虚表地址"<<VTable<<endl;
    for(int i=0;VTable[i]!=0;++i)
    {
        printf("低%d个虚函数地址：0X%x->",i,VTable[i]);

        FUNC f=(FUNC) VTable[i];//转为指针类型
        f();
    }
    cout<<endl;
}
void Test()
{
    Base b1;
    Derive d1;
    int* VTable1=(int*)(*(int*)&b1);
    int* VTable2=(int*)(*(int*)&d1);
    PrintVTable(VTable1);
  PrintVTable(VTable2);//显式打印
}

函数的实现：

这里还有一点不好理解，就是传参问题

探索多继承的内存布局
学习了单继承对象模型，接下来我们看看多继承，同样，通过代码调试观察监视从而了解多继承的内存布局。

class Base1
{
public:
    virtual void fun1()
    {
        cout<<"Base::fun1"<<endl;
    }
    virtual void fun2()
    {
        cout<<"Base::fun2"<<endl;
    }
private:
    int b1;
};
class Base2
{
public:
    virtual void fun1()
    {
        cout<<"Base::fun1"<<endl;
    }
    virtual void fun2()
    {
        cout<<"Base::fun2"<<endl;
    }
private:
    int b2;
};
class Derive:public Base1,public Base2
{
public:
    virtual void fun1()
    {
        cout<<"Derive::fun1"<<endl;
    }
    virtual void fun3()
    {
        cout<<"Derive::fun3"<<endl;
    }

private:
    int d1;
};
typedef void(*FUNC) ();
void PrintVTable(int* VTable)
{
    cout<<"虚表地址"<<VTable<<endl;
    for(int i=0;VTable[i]!=0;++i)
    {
        printf("低%d个虚函数地址：0X%x->",i,VTable[i]);

        FUNC f=(FUNC) VTable[i];//转为指针类型
        f();
    }
    cout<<endl;
}
void Test()
{

    Derive d1;
    int* VTable=(int*)(*(int*)&d1);
    PrintVTable(VTable);
    VTable = (int*)(*((int*)&d1+sizeof(Base1)/4));
    PrintVTable(VTable);//显式打印
}
int main()
{
    Test();
    return 0;
}

多继承中有两个虚函数表，分别是Base1和Base2的虚函数表，我们猜想子类里的fun1()会覆盖父类Base1和Base2中的fun1()，但是子类里的fun3()会放在Base1里还是Base2里还是自己开辟一个虚函数表呢？
接下来，我们通过监视窗口看看：

结果证实了子类里的fun1()会覆盖父类Base1和Base2中的fun1()，但是，同单继承中出现的问题一样，编译器依旧无法在监视窗口中显示出fun3()的情况。
所以，靠自己吧！

通过上图的打印结果可知，fun3()存在于Base1的虚函数表中。当涉及多继承时，子类的虚函数会存放于先继承的那个类的虚函数表里。