虚表的形成

一切结论都必须以事实为依据，这样才能形成长久记忆！

虚表的形成过程：

一、对于非继承类而言：编译器会根据类中是否有虚函数产生虚表，如果有虚函数，则会形成虚表，虚表中会按照成员函数声明顺序存放函数的地址，从而形成存放函数入口地址的函数指针数组，最后把数组地址存放在类的开始的位置，只一个指针的大小。

二、对于继承类而言：对于单继承，如果父类中有虚函数表，则编译器编译时，会把父类的虚表赋值一份，并把新的地址放在类的开始位置，只占一个指针大小的空间；对于多继承，编译器会把多个父类的虚表分别复制一份，并把新的虚表地址依次按照继承顺序存放在子类的开始位置。

三、对于继承时，如果其重写其父类的虚函数（注意重写与重载的区别），编译器会把新的函数的地址更新到原来虚函数对应的位置，如果该类新增虚函数是，编译器会默认把新的虚函数的地址存放第一个虚表中，追加在其后。对于多重继承时，重写会覆盖所有继承虚表中被重写的虚函数地址；新增的虚函数会追加在第一个虚表的内虚表项的后边。

四、虚函数就是指成员函数前加virtual 关键字的函数，但构造函数和友元函数（不是类成员函数）不会是虚函数，其他成员函数都可以使用virtual 修饰，当然纯虚函数也是虚函数。

五、补充：在c++中纯虚函数与纯面向对象的语言,如java、C#，中的接口在功能上是一致的，都是起到接口规范的作用，只是在C++中纯虚函数在类中定义，所以导致在C++中,继承可以是多继承方式，而在纯面向对象中，只能是单继承。

对于以上的结论的图像化的表示，图形方式的表示更直观一点，大家可以参考http://blog.csdn.net/haoel/article/details/1948051。

但是关于这些论点的论证，希望大家参考我的代码。

"朝花夕拾"，为了论证之前结论，自己再次验证一下：

注意：

①要确认当前的主机的位数以及编译器。64位机指针长度8byte,32位机指针长度为4byte.

②注意内存对齐机制，这个机制以为着，申明3byte内存的类大小：sizeof(类名) = 4.关于内存对齐和c语言结构体的对齐方式是一致的。

③空类的大小为1byte，原因是被编译器插进去的一个char ，使得这个class的不同实体（object）在内存中配置独一无二的地址，这样产生的对象的地址才不同。

④继承的时候，无论虚函数的的访问修饰符，和继承的方式如何都可以通过虚表进行调用。

⑤继承的时候，复制虚表本身，并没有复制虚表项中函数指针所指的函数的函数体，即虚函数在内存中的定义只有一份。

 

 以下是验证内容：

结论一：

#include <iostream>

using namespace std;

class A
{

};
class B
{
    virtual void  fun1()
    {
        cout <<"fun1" <<endl;
    }
    virtual void  fun2()
    {
        cout <<"fun2" <<endl;
    }
};

int main()
{
    //空类大小为1
    cout << sizeof(A) <<endl;
    //指针大小为系统位数
    cout << sizeof(new A()) << endl;
    A t_a;
    //对象也是1
    cout << sizeof(t_a) << endl;


    cout << "******************" <<endl;
    
    //两个虚函数，放在一个虚函数表里，最后将虚表的入口地址存放在类开始位置。
    //指针大小为系统位数
    cout << sizeof(B) <<endl;
    //指针大小为系统位数
    cout << sizeof(new B()) << endl;
    B t_b;
    //指针大小为系统位数
    cout << sizeof(t_b) << endl;

    cout << "*******************" << endl;
    //指向对象的地址，指向对象的开始位置
    int *p = (int *)&t_b;
     //指向虚表的第一项
    int *p_fun =  (int *)*p;
    //指向虚表的第二项,
    //sizeof(void *)/sizeof(int) 而不使用1的原因是：
    //在不同位数的系统中，指针的加减的单位是取决于其指针的类型
    //如在32位系统中，int型指针+1,可以指向第二个指针。
    //当时在64位系统中，如果+1，此时指针移动的是sizeof(int)byte的位置，此时指向的不是第二个指针的位置，因为指针大小为8byte。所以使用sizeof(void *)/sizeof(int) 获得每个指针占用几个单位的int型空间。
    int *p_fun2 = p_fun + sizeof(void *)/sizeof(int);
    //将两项内的数据，即函数指针，强转。得到函数指针
    void (*f1)()  = (void (*) (void))*p_fun;
    void (*f2)()  = (void (*) (void))*p_fun2;
    //执行函数指针
    f1();
    f2();
    //打印的时候，需要转换成int型指针才能正常打印
    cout << (int *)f1 <<endl;
    cout << (int *)f2 <<endl;
    

#if 0
    //这种方式，编译器报错
    cout << &(t_b.fun1) << endl;
    
#endif

    return 0;
}

运行结果：

 

结论二：

#include <iostream>

using namespace std;

class A
{
public:
    virtual void a1()
    {
        cout << "a1" <<endl;
    }
    virtual void a2()
    {
        cout << "a2" << endl;
    }
};
class AA
{
    
    virtual void aa1()
    {
        cout << "aa1" <<endl;
    }
    virtual void aa2()
    {
        cout << "aa2" << endl;
    }
};
class B:public A
{
    
};

class C:public A,public AA
{
    
};

int main()
{
    cout << "*****************单继承验证**********************"<<endl;
    cout << sizeof(A) <<endl;
    cout << sizeof(B) <<endl;

    //证明①子类中的虚表与父类虚表入口地址不同
    A t_a;
    int * pa = (int *)&t_a;
    int *pa1 = (int *)*pa;
    cout << "父类虚表地址:" << pa1 <<endl;

    B t_b;
    int * pb = (int *)&t_b;
    int * pb1 = (int *)*pb;
    int * pb2 = pb1 + sizeof(void *)/sizeof(int);
    cout << "子类虚表地址:" << pb1 << endl;
    //结论①:结果地址不同。

    //证明②: 子类中仍然可以通过虚函数调用父类的方法，
    void (*f1)()  = (void (*) (void))*pb1;
    void (*f2)()  = (void (*) (void))*pb2;
    
    f1();
    f2();
    //结论②:子类可以通过新的虚表访问父类的虚函数

    //最终的结论:单继承的时候，是在内存中复制一份虚表，并将新的地址放在子类开始位置
    
    cout << "****************多继承验证*********************"  <<endl;
    //对于多继承，编译器会把多个父类的虚表分别复制一份，并把新的虚表地址依次按照继承顺序存放在子类的开始位置。
    AA t_aa;
    int *paa = (int *)&t_aa;
    int *paa1 = (int *)*paa;

    cout << "父类A的虚表地址:" << pa1 << endl;
    cout << "父类AA的虚表地址:" << paa1 << endl;
    
    C t_c;
    int *pc1 = (int *)&t_c;
    //继承A虚表的入口地址
    int *pc1_1 = (int *)*pc1;
    //继承AA虚表的入口地址
    int *pc2 = pc1 + sizeof(void *)/sizeof(int);
    int *pc2_1 = (int*)*pc2;

    cout << "子类中获得第一项虚表地址:" << pc1_1 << endl;
    cout << "子类中获得第二项虚表地址:" << pc2_1 << endl;
    
    //验证上述地址确实是copy后的新的虚表地址
    cout << "通过继承子类A的虚表执行虚函数" <<endl;
    int *pc1_2 = pc1_1 + sizeof(void *)/sizeof(int);
    void (*fc1_1)()  = (void (*) (void))*pc1_1;
    void (*fc1_2)()  = (void (*) (void))*pc1_2;

    fc1_1();
    fc1_2();
    
    
    cout << "通过继承子类AA的虚表执行虚函数" <<endl;
    int *pc2_2 = pc2_1 + sizeof(void *)/sizeof(int);
    void (*fc2_1)()  = (void (*) (void))*pc2_1;
    void (*fc2_2)()  = (void (*) (void))*pc2_2;

    fc2_1();
    fc2_2();

    return 0;
}　　

 运行截图：

结论三：

#include <iostream>

using namespace std;

class A
{
    public:
        virtual void a1()
        {
            cout << "a1" <<endl;
        }
        virtual void a2()
        {
            cout << "a2" << endl;
        }
};
class AA
{

    virtual void a1()
    {   
        cout << "aa1" <<endl;
    }   
    virtual void aa2()
    {   
        cout << "aa2" << endl;
    }   
};
class B:public A
{

};

class BB:public A
{
    //重写A的虚函数,注意不是重载，重载不是一个函数，只是函数名相同罢了
    virtual void a1()
    {
        cout << "bb1" <<endl;
    }
    virtual void a2()
    {
        cout << "bb2" << endl;
    }
    //新增虚函数的时候，会将新增的虚函数地址作为新的表项，追加在原虚表的后边
    virtual void b3()
    {
        cout << "bb3" << endl;
    }
};

class C:public A,public AA
{
    //重写A的虚函数,注意不是重载，重载不是一个函数，只是函数名相同罢了
    virtual void a1()
    {
        cout << "cc1" <<endl;
    }
    virtual void a2()
    {
        cout << "cc2" << endl;
    }
    //新增虚函数的时候，会将新增的虚函数地址作为新的表项，追加在原虚表的后边
    virtual void b3()
    {
        cout << "cc3" << endl;
    }
};


int main()
{
    A t_a;
    int * pa = (int *)&t_a;
    int *pa1 = (int *)*pa;
    //cout << "父类虚表地址:" << pa1 <<endl;

    B t_b;
    int * pb = (int *)&t_b;
    int * pb1 = (int *)*pb;
    int * pb2 = pb1 + sizeof(void *)/sizeof(int);
    //cout << "子类虚表地址:" << pb1 << endl;

    void (*f1)()  = (void (*) (void))*pb1;
    void (*f2)()  = (void (*) (void))*pb2;

    f1();
    f2();
    //结论②:子类可以通过新的虚表访问父类的虚函数


    BB t_bb;
    int * pbb = (int *)&t_bb;
    int * pbb1 = (int *)*pbb;
    int * pbb2 = pbb1 + sizeof(void *)/sizeof(int);
    int * pbb3 = pbb2 + sizeof(void *)/sizeof(int);
    //cout << "子类虚表地址:" << pb1 << endl;

    void (*fb1)()  = (void (*) (void))*pbb1;
    void (*fb2)()  = (void (*) (void))*pbb2;
    void (*fb3)()  = (void (*) (void))*pbb3;
    cout << "***********************单继承的情况****************************" << endl;

    cout  << "验证重写的时候，覆盖原虚表中被重写的虚函数的入口地址" << endl;
    fb1();
    fb2();
    cout  << "验证新增虚函数的时候，追加在虚表已有表项的后边" << endl;
    fb3();

    
    cout << "***********************多继承的情况****************************" << endl;
    //验证多重继承的时候，重写的虚函数地址会覆盖所有虚表中中被重写的虚函数地址，
    //验证多重继承的时候，新增虚函数会自动追加到第一个继承虚表的后边。不会再追加到继承的其他虚表的虚表项。
    
    C t_c;
    //虚表1    
    int * pc1 = (int *)&t_c;
    //虚表1的表项1
    int * pc1_1 = (int *)*pc1;
    //虚表1的表项2
    int * pc1_2 = pc1_1 + sizeof(void *)/sizeof(int);
    //虚表1的表项3
    int * pc1_3 = pc1_2 + sizeof(void *)/sizeof(int);
    
    //虚表2
    int * pc2 = pc1 + sizeof(void *)/sizeof(int);
    //虚表2的表项1
    int * pc2_1 = (int *)*pc2;
    //虚表2的表项2
    int * pc2_2 = pc2_1 + sizeof(void *)/sizeof(int);
    //虚表2的表项3
    int * pc2_3 = pc2_2 + sizeof(void *)/sizeof(int);

    //重写A的虚函数1
    void (*fc1_1)()  = (void (*) (void))*pc1_1;
    //重写A的虚函数2
    void (*fc1_2)()  = (void (*) (void))*pc1_2;
    //追加新的虚函数3
    void (*fc1_3)()  = (void (*) (void))*pc1_3;
    
    
    //重写AA的虚函数1，因为A和AA的第一个虚函数是相同的
    void (*fc2_1)()  = (void (*) (void))*pc2_1;
    //继承AA的虚函数2
    void (*fc2_2)()  = (void (*) (void))*pc2_2;
    //追加新的虚函数3,段错误，只追加到第一个虚表的后边,当前是虚表2，没有追加，如果访问就段错误
    void (*fc2_3)()  = (void (*) (void))*pc2_3;
    
    cout << "重写A的虚函数1" << endl;
    fc1_1();
    cout << "重写A的虚函数2" << endl;
    fc1_2();
    cout << "追加虚表1的虚函数" << endl;
    fc1_3();


    cout << "重写AA的虚函数1" << endl;
    fc2_1();
    cout << "继承AA的虚函数2" << endl;
    fc2_2();
    //cout << "追加虚表1的虚函数" << endl;
    //fc2_3();

    return 0;
}

 运行截图：