对象多继承中的数据结构分析

为了探索类继承数据结构，构造如下几个类：

 

Class BaseA:

Class BaseB public BaseA

Class BaseC

Class BaseD

Class BaseE public BaseC, public BaseD

Class DriveF public BaseB, public BaseE

 

 

 

代码：

#include <iostream>

using namespace std;

 

class BaseA {

public:

    BaseA() {cout << "In BaseA/n";}

    virtual void fa() { cout << "BaseA::fa/n"; }

    virtual void faa() { cout << "BaseA::faa/n"; }

    int a;

};

 

class BaseB  : public BaseA {

public:

    BaseB () {cout << "In BaseB /n"; }

    virtual void fb() { cout << "BaseB ::fb/n"; }

    virtual void fbb() { cout << "BaseB ::fbb/n"; }

    int b;

};

 

class BaseC  {

public:

    BaseC () {cout << "In BaseC /n";}

    virtual void fc() { cout << "BaseC ::fc/n"; }

    virtual void fcc() { cout << "BaseC ::fcc/n"; }

    int c;

};

 

class BaseD {

public:

    BaseD() {cout << "In BaseD/n";}

    virtual void fd() { cout << "BaseD::fd/n"; }

    virtual void fdd() { cout << "BaseD::fdd/n"; }

    int d;

};

 

class BaseE : public BaseC , public BaseD

{

public:

    BaseE() {cout << "In BaseE/n"; }

    virtual void fe() { cout << "BaseE::fe/n"; }

    virtual void fee() { cout << "BaseE::fee/n"; }

    int e;

};

 

class DriveF : public BaseB , public BaseE

{

    public:

    DriveF(){cout << "In DriveF/n";}

    virtual void ff(){cout << "DriveF::ff/n"; }

    virtual void fff(){cout << "DriveF::fff/n"; }

    int f;

};

 

typedef void(*F)(void);

 

int main(void)

{

    cout << "/n创建BaseA对象/n";

    BaseA ba;

    ba.a = 9;

 

    int *pob  = (int*)(&ba) ;                  //对象地址

    int *pvt = (int*)(*pob) ;                  //对象的虚表地址

    F f = F( *pvt );                           //虚表第一个虚函数

f();

f = F( *(pvt+1) );                         //虚表第二个虚函数

    f();

 

    cout << "BaseA.a = " << *(pob+1) << "/n";    //数据成员a

   

    cout << "/n创建BaseB 对象/n";

    BaseB  bb;

    bb.a = 8; bb.b=7;

 

    pob  = (int*)(&bb) ;                 //对象地址

    pvt = (int*)(*pob) ;                 // BaseB虚表

    f = F( *pvt );                              //BaseA第一个虚函数

    f();

    f = F( *(pvt+1) );                          //BaseA第二个虚函数

    f();

 

    f = F( *(pvt+2) );                           //BaseB虚表第一个虚函数

    f();

    f = F( *(pvt+3) );                           //BaseB虚表第二个虚函数

    f();

    cout << "BaseB.BaseA.a = " << *(pob+1) << "/n";  //BaseA数据成员a

    cout <<"BaseB.b = " <<*(pob+2 ) << "/n";       //BaseB数据成员b

   

    cout << "/n创建DriveF对象/n";

    DriveF df;

    df.a = 1,

    df.b = 2;

    df.c = 3;

    df.d = 4;

    df.e = 5;

    df.f = 6;

 

    pob  = (int*)(&df) ;       //对象地址

    pvt = (int*)(*pob) ;        //对象的虚表地址

 

    F f4 = F( *pvt );           //BaseA 第一个虚函数

    f4();

    f4 = F( *(pvt+1) );         //BaseA 第二个虚函数

    f4();

 

    F f5 = F( *(pvt+2) );       // BaseB 第一个虚函数

    f5();

    f5 = F( *(pvt+3) );         // BaseB 第二个虚函数

    f5();

 

    F f6 = F( *(pvt+4) );       //DriveF 第一个虚函数

    f6();

    f6 = F( *(pvt+5) );         //DriveF 第二个虚函数

    f6();

 

    F f7 = F( *(int*)*(pob+3) );    //BaseC  第一个虚函数

    f7();

    f7 = F( *((int*)*(pob+3)+1) );  //BaseC  第二个虚函数

    f7();

 

    F f8 = F( *(int*)*(pob+5) );    //BaseD 第一个虚函数

    f8();

    f8 = F( *((int*)*(pob+5)+1) );  //BaseD 第二个虚函数

    f8();

 

    F f9 = F( *( (int*)*(pob+3)+2 ) );  //BaseE 第一个虚函数

    f9();

    f9 = F( *( (int*)*(pob+3)+3 ) );    //BaseE 第二个虚函数

    f9();

 

    cout <<"DriveF.BaseB.BaseA.a = "<< *(pob+1) << "/n";//BaseA数据成员a

    cout <<"DriveF.BaseB.b = " <<*(pob+2 ) << "/n";    //BaseB数据成员b

    cout <<"DriveF.BaseC.c = " <<*(pob+4) << "/n";     //BaseC 数据成员c

    cout <<" DriveF.BaseD.d = " <<*(pob+6) << "/n";    //BaseD数据成员d

    cout <<" DriveF.BaseE.e = " <<*(pob+7) << "/n";    //BaseE数据成员e

    cout <<"DriveF.f = " <<*(pob+8) << "/n";           //DriveF数组成员f

 

    return 0;

}

 

结论图示：