探索C++对象模型

首先声明：下面的测试都是windoes32位 vs2013的环境下进行测试的：
本节的主要目标：
- 探索多态的实现–虚表
- 探索单继承&多继承的对象模型
- 理解静态绑定和动态绑定
- 菱形继承&菱形虚拟继承的对象模型

首先理解多态的定义,首先必须是继承的体系下有虚函数的重写，其次必须是父类的指针或者引用去调用子类的虚函数，只有这两个条件同时存在才能构成多态

1.探索虚函数表
概念：虚函数表是通过一块连续的内存来存储虚函数的地址。这张表解决了继承，虚函数重写的问题。在有虚函数的对象实例中都存在一张虚函数表，虚函数表就像一张地图，指明了实际应该调用的虚函数。
看这段代码：

class Base
{
public:
    virtual void func1()
    {}

    virtual void func2()
    {}

private:
    int a;
};

void test()
{
    Base b1;
    int a=sizeof(b1);
    cout << a << endl;

}

先来看一下这个sizeof的结果是8，那多出的四个自己是什么呢？多出的四个字节就是虚表指针

由上图可以看出在对象的上面存放的是一个虚表指针，这个指针指向一个称为vtbl（虚函数表）的函数指针数组，每个有虚函数的类都含有一个虚函数表。

注意，千万不能将虚表和虚基表混淆了，这两个是没有任何关系的。
虚基表是在用虚继承来解决菱形继承体系下数据冗余和二义性问题时候才会出现的，虚基表中存放的是这个位置相对于公共数据成员的偏移量。

2.单继承下的对象模型（现在讨论的都是有子类有虚函数覆盖父类虚函数的情况，因为如果没有覆盖也没啥可说的）

先看代码

class Base
{
public:
    virtual void f(){}
    virtual void g(){}

private:
    int a=1;
};

class Dirve :public Base
{
public:
    virtual void f(){}
    virtual void g1(){}

};

子类只是将父类的 f() 函数重写了，但是g没有重写。我们先观察一下 d对象中虚表指针所指向的空间内容

由图中可以看到d对象的虚表中存放了三个地址，b对象中存放了两个地址，而且而且b对象中的第一个地址与d对象的不同，但是第二个却相同，说明子类虚表构成是是先放父类的虚函数，如果子类没有将其重写，则将自己的虚函数放在父类虚函数的后面，如果子类对父类虚函数进行重写，则是将父类相对应的虚函数进行替换，父类其他没被重写的虚函数位置不变，最后再将子类自己的虚函数加在后面。

3.多继承下的对象模型

class Base1
{
public:
    virtual void f(){}
    virtual void g(){}
};
class Base2
{
public:
    virtual void f(){}
    virtual void g(){}
};

class Dirve :public Base1,Base2
{
public:
    virtual void f1(){}
    virtual void g1(){}
};

这是内存窗口的虚表：


从这里观察到第一张里面有四个地址，而第二个里面有两个地址，所以在多继承无覆盖的时候，子类继承了多少个父类就会有几张虚表，然后将自己的虚函数放在第一张虚表后面（先后顺序是按照继承的顺序来的）
但是如果将代码变成下面的

class Base1
{
public:
    virtual void func1(){}
    virtual void func2(){}
};

class Base2
{
public:
    virtual void func1(){}
    virtual void func2(){}
};
class Derive : public Base1, public Base2
{
public:
    virtual void func1(){}
    virtual void func3(){}
};

Derive继承了Base1和Base2 ，而且重写了funk，虚表又会变成怎样的

此时子类中重写的func1 已经将父类的func1进行替换，而且将自己的func3放在父类的func2的后面。

第二个父类就只是将func1进行重写，如果不相信内存，还可以打印虚表

地址完全相同，没毛病！

4.什么是动态绑定？静态绑定呢？
前面已经说过多态的概念，C++的多态分为静态多态和动态多态。

• 静态多态就是重载，因为是在编译期决议确定（具体的决议准则是是：作用域+返回类型+参数名+参数列表），所以称为静态多态。
• 动态多态就是通过继承重写基类的虚函数实现的多态，因为是在运行时决议确定，所以称为动态多态。

class Base
{
public:
    virtual void func1(){}
    virtual void func2(){}
    void display(){}
private:
    int a;
};

class Derive :public Base
{
public:
    virtual void func1(){}
private:
    int b;
};

void func(Base& b)
{
    b.func1();
    b.display();
}

void Test1()
{
    Base b1;
    Derive d1;
    func(b1);
    func(d1);
}

func 1要去虚表中找，而普通函数直接调用
再看将d对象传给父类的引用时，就构成多态了

5.菱形继承下的对象模型

    class Base1 :public Base
{
public:
    virtual void f(){ cout << "B::func1" << endl; }
    virtual void f1(){}
    virtual void Bf1(){}
private:
    int b1;
};

class Base2 :public Base
{
public:
    virtual void f(){ cout << "B::func1" << endl; }
    virtual void f2(){}
    virtual void Bf2(){}
private:
    int b2;
};
class Derive :public Base1,Base2
{
public:
    virtual void f(){ cout << "D::func1"; }
    virtual void f1(){}
    virtual void f2(){}
    virtual void Df(){};
private:
    int d;
    int d1;
};

这是一般的菱形继承，那d对象里面是如何分布的呢？

这个时候还只有两张虚表，但是这里的问题之前在学习继承中就说到了，有二义性和数据冗余的问题，所以解决的方法就是让Base1和Base2 虚拟继承Base类，这样的话Dirve类的对象布局就更麻烦了
先看内存

用图形画出大概就是这样的

不过地址偏移里面为什么存的是-4还有待进一步研究。。。

6.再来说说概念，为什么需要将父类的析构函数设置成虚函数呢？
其实是因为有时候我们会用父类的指针或者引用指向new出来的子类对象，而如果不将父类的析构函数设置成虚函数，就会造成内存泄漏。