c++虚表（vftable）、虚函数指针（vfptr）、虚基指针（vbptr）的测试结果

///
///  @filename   
///  @author     whao Luo
///  @email      haohb13@gmail.com
///  @date       
///

#if 0
//测试虚表的存在

#include <iostream>
using namespace std;
class A
{
    int i = 10;
    int ia = 100;
    void func() {}
    virtual void run() { cout << "A::run()" << endl; }
    virtual void run1() { cout << "A::run1()" << endl; }
    virtual void run2() { cout << "A::run2()" << endl; }
};
class B : public A
{
    virtual void run() { cout << "B::run()" << endl; }
    virtual void run1() { cout << "B::run1()" << endl; }
};
class C :public A
{
    virtual void run() { cout << "C::run()" << endl; }
    virtual void run1() { cout << "C::run1()" << endl; }
    virtual void run3() { cout << "C::run3()" << endl; }
};
class D :/*virtual*/ public A
{
    virtual void run() { cout << "D::run()" << endl; }
    virtual void run1() { cout << "D::run1()" << endl; }
    virtual void run2() { cout << "D::run2()" << endl; }
    virtual void run3() { cout << "D::run3()" << endl; }
};

int test()
{
    cout << sizeof(A) << endl
         << sizeof(B) << endl
         << sizeof(C) << endl
         << sizeof(D) << endl;
    cout << sizeof(long long) << endl;
    //A * pA = new D;
    D d;
    //d.run();

    typedef void(*Function)(void);

    int ** pVtable = (int **)&d;

#if 0
    int * pVtable = (int*)&d;
    int vtaleAdress = *pVtable;

    int * ppVtable = (int*)vtaleAdress;
    int func1 = *ppVtable;

    Function f1 = (Function)func1;
    f1()
#endif
    //pVtable[0][0]

    for (int idx = 0; pVtable[0][idx] != NULL; ++idx)
    {
        Function f = (Function)pVtable[0][idx];
        f();
    }

    //cout << (int)pVtable[1] << endl;
    //cout << (int)pVtable[2] << endl;

    getchar();
    return 0;
}

int main(void)
{
    test();
    return 0;
}

#endif

#if 0
// 测试一：单个虚继承，不带虚函数
//  虚继承与继承的区别
//  １.　多了一个虚基指针
//  ２.　虚基类位于派生类存储空间的最末尾

// 测试二：单个虚继承，带虚函数
//   1.如果派生类没有自己的虚函数，此时派生类对象不会产生
//　   虚函数指针
//   2.如果派生类拥有自己的虚函数，此时派生类对象就会产生自己本身的虚函数指针，
//     并且该虚函数指针位于派生类对象存储空间的开始位置
//

#pragma vtordisp(off)
#include <iostream>
using std::cout;
using std::endl;

class A
{
public:
    A() : _ia(10){}

    virtual
    void f()
    {   cout << "A::f()" << endl;   }
private:
    int _ia;
};

class B
:  /*virtual*/ public A
{
public:
    B() : _ib(20){}

    void fb()
    {   cout << "A::fb()" << endl;  }


    virtual void f()
    {   cout << "B::f()" << endl;   }

#if 1
    virtual void fb2()  
    {   cout << "B::fb2()" << endl; }
#endif

private:
    int _ib;
};

int main(void)
{
    cout << sizeof(A) << endl;
    cout << sizeof(B) << endl;
    B b;
    getchar();
    return 0;
}

#endif

///
///  @filename   
///  @author     whao Luo
///  @email      haohb13@gmail.com
///  @date       
///

// 测试三：多重继承（带虚函数）
//　１.　每个基类都有自己的虚函数表
//  ２.　派生类如果有自己的虚函数，会被加入到第一个虚函数表之中
//  ３.  内存布局中，　其基类的布局按照基类被声明时的顺序进行排列
//　４.　派生类会覆盖基类的虚函数，只有第一个虚函数表中存放的是
//      真实的被覆盖的函数的地址；其它的虚函数表中存放的并不是真实的
//      对应的虚函数的地址，而只是一条跳转指令
#if 0
#pragma vtordisp(off)
#include <iostream>

using std::cout;
using std::endl;

class Base1
{
public:
    Base1() : _iBase1(10){}
    virtual void f()
    {   cout << "Base1::f()" << endl;   }

    virtual void g()
    {   cout << "Base1::g()" << endl;   }

    virtual void h()
    {   cout << "Base1::h()" << endl;   }
private:
    int _iBase1;
};

class Base2
{
public:
    Base2() : _iBase2(100){}
    virtual void f()
    {
        cout << "Base2::f()" << endl;
    }

    virtual void g()
    {
        cout << "Base2::g()" << endl;
    }

    virtual void h()
    {
        cout << "Base2::h()" << endl;
    }
private:
    int _iBase2;
};

class Base3
{
public:
    Base3() : _iBase3(1000){}
    virtual void f()
    {
        cout << "Base3::f()" << endl;
    }

    virtual void g()
    {
        cout << "Base3::g()" << endl;
    }

    virtual void h()
    {
        cout << "Base3::h()" << endl;
    }
private:
    int _iBase3;
};


class Derived
    : virtual public Base1
    , public Base2
    , public Base3
{
public:
    Derived() : _iDerived(10000){}
    void f()
    {   cout << "Derived::f()" << endl; }

    virtual void g1()
    {   cout << "Derived::g1()" << endl;    }

private:
    int _iDerived;  
};

int main(void)
{
    Derived d;
    Base2 * pBase2 = &d;
    Base3 * pBase3 = &d;
    Derived * pDerived = &d;

    pBase2->f();
    cout << "sizeof(d) = "<< sizeof(d) << endl;

    cout << "&Derived = " << &d << endl;   // 这三个地址值是不一样的
    cout << "pBase2 = " << pBase2 << endl; //
    cout << "pBase3 = " << pBase3 << endl; //

    getchar();

    return 0;
}

#endif

///
///  @filename   
///  @author     whao Luo
///  @email      haohb13@gmail.com
///  @date       
///

// 测试四：钻石型虚继承

//虚基指针所指向的虚基表的内容：
//  1. 虚基指针的第一条内容表示的是该虚基指针距离所在的子对象的首地址的偏移
//  2. 虚基指针的第二条内容表示的是该虚基指针距离虚基类子对象的首地址的偏移
#if 1

#pragma vtordisp(off)
#include <iostream>
using std::cout;
using std::endl;

class B
{
public:
    B() : _ib(10), _cb('B'){}

    virtual void f()
    {
        cout << "B::f()" << endl;
    }

    virtual void Bf()
    {
        cout << "B::Bf()" << endl;
    }

private:
    int _ib;
    char _cb;
};

class B1 : virtual public B
{
public:
    B1() : _ib1(100), _cb1('1'){}

    virtual void f()
    {   cout << "B1::f()" << endl;  }   

#if 1
    virtual void f1()
    {
        cout << "B1::f1()" << endl;
    }
    virtual void Bf1()
    {
        cout << "B1::Bf1()" << endl;
    }
#endif

private:
    int _ib1;
    char _cb1;
};



class B2 : virtual public B
{
public:
    B2() : _ib2(1000), _cb2('2'){}

    virtual void f()
    {
        cout << "B2::f()" << endl;
    }
#if 1
    virtual void f2()
    {
        cout << "B2::f2()" << endl;
    }
    virtual void Bf2()
    {
        cout << "B2::Bf2()" << endl;
    }
    #endif
private:
    int _ib2;
    char _cb2;
};

class D : public B1, public B2
{
public:
    D() : _id(10000), _cd('3'){}


    virtual void f()
    {
        cout << "D::f()" << endl;
    }

#if 1
    virtual void f1()
    {
        cout << "D::f1()" << endl;
    }
    virtual void f2()
    {
        cout << "D::f2()" << endl;
    }

    virtual void Df()
    {
        cout << "D::Df()" << endl;
    }
#endif
private:
    int _id;
    char _cd;
};

int main(void)
{
    D d;
    cout << sizeof(d) << endl;
    getchar();
    return 0;
}

#endif