C++ 继承、多继承、虚拟继承对象模型

C++面向对象语言一大难点是继承，但又是不得不掌握的。简单的继承是很容易理解的，但是当涉及到多继承，设计到虚函数的继承，特别是涉及到虚继承时，问题就会变得复杂。下面的内容来自参考资料中的三篇文章。C++的继承学习中，最主要是要掌握派生类的对象模型，基类和派生类指针之间的向上向下类型转换，当继承中的出现虚函数成员函数的访问（多态），虚继承是如何通过引入虚基表解决“菱形继承”中存在多份公共基类的问题。

一、简单的对象模型

1.定义

class MyClass {
public:
    int var;
    void foo(){} //普通成员函数
    virtual void fun() {} //虚拟成员函数
};

MyClass对象大小是8个字节。前四个字节存储的是虚函数表的指针vfptr，后四个字节存储对象成员var的值。虚函数表的大小为4字节，就一条函数地址，即虚函数fun的地址，它在虚函数表vftable的偏移是0。因此，MyClass对象模型的结果如图下图所示（在64位机器中，指针的大小是8个字节。所以MyClass对象大小是应该是16个字节。前8个字节存储的是虚函数表的指针vfptr，后四个字节存储对象成员var的值，加上内存对齐是16个字节）

MyClass的虚函数表虽然只有一条函数记录，但是它的结尾处是由4字节的0作为结束标记的。

adjust表示虚函数机制执行时，this指针的调整量，假如fun被多态调用的话，那么它的形式如下：

*(this+0)[0]()

总结虚函数调用形式，应该是：

*(this指针+调整量)[虚函数在vftable内的偏移]()

二、单继承

定义派生类MyclassA，继承自MyClass类，重写了foo(),fun(),定义了funA()。

在单继承形式下，子类的完全获得父类的虚函数表和数据。子类如果重写了父类的虚函数（如fun），就会把虚函数表原本fun对应的记录（内容MyClass::fun）覆盖为新的函数地址（内容MyClassA::fun），否则继续保持原本的函数地址记录。如果子类定义了新的虚函数，虚函数表内会追加一条记录，记录该函数的地址（如MyClassA::funA）。它的对象模型如下图所示。

class MyClassA: public MyClass {
public:
    int varA;
    void foo(){
    }
    virtual void fun() {
    }
    virtual void funA() {
    }
};

　　非虚继承下的向上向下类型转换是容易的，使用静态转换完成。当派生类重写了基类的方法时，普通成员函数的访问取决于指针的类型，虚函数的访问取决于指针所指向的内容。对于非虚的成员函数来说，调用哪个成员函数是在编译时，根据“->”操作符左边指针表达式的类型静态决定的。对于虚函数调用来说，调用哪个成员函数在运行时 决定。不管“->”操作符左边的指针表达式的类型如何，调用的虚函数都是由指针实际指向的实例类型所决定。（这就是c++中的多态）。为了实现这种机制，引入了隐藏的vfptr 成员变量。 一个vfptr被加入到类中（如果类中没有的话），该vfptr指向类的虚函数表（vftable）。类中每个虚函数在该类的虚函数表中都占据一项。每项保存一个对于该类适用的虚函数的地址。因此，调用虚函数的过程如下：取得实例的vfptr；通过vfptr得到虚函数表的一项；通过虚函数表该项的函数地址间接调用虚函数。也就是说，在普通函数调用的参数传递、调用、返回指令开销外，虚函数调用还需要额外的开销。

例如下例子中：

  • 普通成员函数foo()函数的调用，无论对象的内容是什么，derivaed->foo()始终调用派生类中的foo函数，base->foo()始终调用基类中foo函数。
  • 虚函数调用取决于指针所指向的对象类型，例如第一个base->fun()，因为base指向的是一个派生对象，调用的是派生类中的fun()方法。同类向下转换中derivedA->fun()调用的是基类中的fun（）函数。
    //向上转换
    MyClassA* derivedA= new MyClassA();
    MyClass* base = static_cast<MyClass*>(derivedA);
    derivedA->foo();   //MyClassA:foo()
    derivedA->fun();   //MyClassA:fun()
    base->foo();       //MyClass:foo()
    base->fun();       //MyClassA:fun() 多态

    //向下转换base = new MyClass();
    derivedA = static_cast<MyClassA*>(base);
    base->foo();       //MyClass:foo()
    base->fun();       //MyClass:fun()
    derivedA->foo();   //MyClassA:foo()
    derivedA->fun();   //MyClass:fun()

三、多继承

为了介绍，定义MyClassB，MyClassB和MyClassA类似，就不赘述了。同时也定义一个MyClassC同时继承自MyClassA、MyClassB。

class MyClassB: public MyClass {
public:
    int varB;
    void foo(){}
    virtual void fun() {}
    virtual void funB(){}
};

class MyClassC : public MyClassA,public MyClassB{
public:
    int varC;
    void foo(){}
    virtual void funB(){}
    virtual void funcC(){}
};

和单重继承类似，多重继承时MyClassC会把所有的父类全部按序包含在自身内部，而且每一个父类都对应一个单独的虚函数表。
多重继承下，子类不再具有自身的虚函数表，它的虚函数表与第一个父类的虚函数表合并了。同样的，如果子类重写了任意父类的虚函数，都会覆盖对应的函数地址记录。如果MyClassC重写了fun函数（两个父类都有该函数），那么两个虚函数表的记录都需要被覆盖！在这里我们发现MyClassC::funB的函数对应的adjust值是12，按照我们前边的规则，可以发现该函数的多态调用形式为：
*(this+12)[1]()
此处的调整量12正好是MyClassB的vfptr在MyClassC对象内的偏移量。（32位的机器）

多继承和单继承一样都可以使用静态转换完成向下的类型转换，但是转换到不同类型，指针的地址是不同的。

    MyClassC* ddc = new MyClassC();
    MyClassA* da = static_cast<MyClassA*>(ddc);
    MyClassB* db = static_cast<MyClassB*>(ddc);
    cout << ddc << endl;  //0x11a7c20
    cout << da << endl;   //0x11a7c20，第一个继承类MyClassA
    cout << db << endl;   //0x11a7c30，第二个继承类MyClassB

另外，在这个多继承关系中，两个继承类MyClassA和MyClassB都继承类MyClass类，这种继承关系也被称为”菱形“继承。

细心的读者会发现，派生类存在多份，公共基类的成员，本样例中的var成员变量。

菱形继承关系中，直接向上转换成公共基类会是不可以的，也无法直接访问公共基类的成员，因为在编译器看来都是模糊的行为，不知道来自MyclassA还是MyClassB，编译器都会报错

    MyClass* base = static_cast<MyClass*>(ddc);
    cout << ddc->var << endl;

error: ‘MyClass’ is an ambiguous base of ‘MyClassC’

error: request for member ‘var’ is ambiguous

正确的做法要指明来自哪个继承类，避免产生歧义

    MyClass* base = static_cast<MyClass*>(static_cast<MyClassA*>(ddc));
    cout << ddc->MyClassA::var << endl;

四、虚继承

C++中为了避免菱形继承中，派生类存在多费公共基类的拷贝问题，引入了虚继承的概念。

虚继承中引入了虚基表指针，使得继承问题变得更加复杂。虽然在单继承中，一般不会出现虚继承，但是为了一步一步的理解虚继承还是从单继承的虚继承开始。

使用虚继承非常简单，只需要在普通继承前面加上virtual关键字就可以啦，例如MyClassA虚继承自MyClass类：

class MyClassA:  virtual public MyClass {
public:
    int varA;
    void foo(){
    }
    virtual void fun() {
    }
    virtual void funA() {
    }
};

MyClassA对象的内存布局，MyClassA类的大小在VS64位平台下是40个字节，GCC64位平台32个字节。这两种在虚继承上的实现可能有些不同，这里以VS编译器为类介绍MyClassA对象的模型。下面是使用vs2012看到到MyClassA的

class MyClassA size(40):
1> +---
1> 0 | {vfptr}
1> 8 | {vbptr}
1> 16 | varA
1> | <alignment member> (size=4)
1> +---
1> +--- (virtual base MyClass)
1> 24 | {vfptr}
1> 32 | var
1> | <alignment member> (size=4)
1> +---
1>
1> MyClassA::[email protected]@:
1> | &MyClassA_meta
1> | 0
1> 0 | &MyClassA::funA
1>
1> MyClassA::[email protected]:
1> 0 | -8
1> 1 | 16 (MyClassAd(MyClassA+8)MyClass)
1>
1> MyClassA::[email protected]@:
1> | -24
1> 0 | &MyClassA::fun
1>
1> MyClassA::fun this adjustor: 24
1> MyClassA::funA this adjustor: 0

转换成图形，如下图所示，vbtable中的-8表示第一个vfptr与vbptr之间的偏移差，16表示第二个vfptr与vbptr之间的偏移差。

我们所过虚继承最大的意义在于“菱形继承”中避免派生类拥有多份公共积累的内容。同类重新定义MyClassB虚继承自MyClass，MyClassA继承自MyClassA和MyClassB。

MyClassB的内存结构和MyClassA的内存结构类似，不再赘述了。主要分析MyClassC的内存结构。

class MyClassB: virtual public MyClass {
public:
    int varB;
    void foo(){}
    virtual void fun() {}
    virtual void funB() {}
};

class MyClassC : public MyClassA,public MyClassB{
public:
    int varC;
    void foo(){}
    virtual void funB(){}
    virtual void funC(){}　　 virtual void fun(){}
};

1> class MyClassC size(72):
1> +---
1> | +--- (base class MyClassA)
1> 0 | | {vfptr}
1> 8 | | {vbptr}
1> 16 | | varA
1> | | <alignment member> (size=4)
1> | +---
1> | +--- (base class MyClassB)
1> 24 | | {vfptr}
1> 32 | | {vbptr}
1> 40 | | varB
1> | | <alignment member> (size=4)
1> | +---
1> 48 | varC
1> | <alignment member> (size=4)
1> +---
1> +--- (virtual base MyClass)
1> 56 | {vfptr}
1> 64 | var
1> | <alignment member> (size=4)
1> +---
1>
1> MyClassC::[email protected]@:
1> | &MyClassC_meta
1> | 0
1> 0 | &MyClassA::funA
1> 1 | &MyClassC::funC
1>
1> MyClassC::[email protected]@:
1> | -24
1> 0 | &MyClassC::funB
1>
1> MyClassC::[email protected]@:
1> 0 | -8
1> 1 | 48 (MyClassCd(MyClassA+8)MyClass)
1>
1> MyClassC::[email protected]@:
1> 0 | -8
1> 1 | 24 (MyClassCd(MyClassB+8)MyClass)
1>
1> MyClassC::[email protected]@:
1> | -56
1> 0 | &MyClassC::fun
1>
1> MyClassC::funB this adjustor: 24
1> MyClassC::funC this adjustor: 0
1> MyClassC::fun this adjustor: 56

注意一下MyClassC对象模型，发现从上到下显示虚继承类的内容，按照继承顺序先是MyClassA的内容，然后是MyClassB的内容，最后是公共基类的内容，例外每个虚继承类都带有一个虚基表指针。

虚继承中虚拟公共基类成员的访问：

虚拟继承能避免菱形继承中公共基类成员访问会产生歧义的问题，是怎么做到的呢？我们知道在在非继承、单继承甚至多继承关系中，成员的访问都是通多基类指针和基类成员之间的偏移量来完成的。虚继承中，访问虚基类的成员任然是计算固定偏移量，但是访问公共的虚基类的成员，开销就变得非常大，需要访问两个虚拟指针的内容，具体的步骤如下：

    MyClassC* vddc = new MyClassC();
    cout << vddc->var << endl;

1.获取一个虚基表指针，这里是第一个vbtr

2.获取虚基表中某一项的内容，这里是40

3.把内容中指出的偏移量加到“虚基类表指针”的地址上，访问公共的虚基类的内容。

虚继承中的向上向下类型转换：

1.虚继承中向上转换和一般继承一样，使用static_cast静态转换

    MyClassC* vddc = new MyClassC();
    MyClassA* vda = static_cast<MyClassA*>(vddc);

2.虚拟继承中的公共的虚拟基类向下转换是不可以使用静态转换的，因为需要运行时的信息。

    MyClass* vd = new MyClass();
    MyClassC* vddc = static_cast<MyClassC*>(vd);

error: cannot convert from pointer to base class ‘MyClass’ to pointer to derived class ‘MyClassC’ because the base is virtual

需要使用动态转换，dynamic_cast

    MyClass* vd = new MyClass();
    MyClassC* vddc = dynamic_cast<MyClassC*>(vd);

通过以上的描述，我们基本认清了C++的对象模型。尤其是在多重、虚拟继承下的复杂结构。通过这些真实的例子，使得我们认清C++内class的本质，以此指导我们更好的书写我们的程序。本文从对象结构的角度结合图例为大家阐述对象的基本模型，和一般描述C++虚拟机制的文章有所不同。作者只希望借助于图表能把C++对象以更好理解的形式为大家展现出来，希望本文对你有所帮助。

参考资料：

1.http://www.cnblogs.com/fanzhidongyzby/archive/2013/01/14/2859064.html

2.http://www.oschina.net/translate/cpp-virtual-inheritance

3.http://www.cnblogs.com/cy568searchx/p/3707384.html

时间： 2024-02-20 09:43:27

C++ 继承、多继承、虚拟继承对象模型的相关文章

深入探索Ｃ＋＋对象象模型--拷贝构造函数 &amp;&amp;多重继承　虚拟继承　内存分布

拷贝构造函数 如果没有定义拷贝构造函数,那么编译器会自动生成一个拷贝构造函数,但是这个拷贝构造函数是有一定限度的. 一般来说这个拷贝构造函数是按照位直接拷贝的,但是在有些情况下这种初始化是有问题的,在特殊的四种情况下是有问题的,在有问题的情况下,可以举例说明. 如果一个有多态性质的对象,子类赋值给父类,调用了拷贝构造函数,这个时候就需要给父类的虚拟函数表重新分配,使得虚拟函数表和子类不是同一个,这样bitwist就不能有效 对于在函数参数中调用拷贝构造函数,参数是实参的一根拷贝,对于函数的返回值

关于C++中的虚拟继承的一些总结

1.为什么要引入虚拟继承 虚拟继承是多重继承中特有的概念.虚拟基类是为解决多重继承而出现的.如:类D继承自类B1.B2,而类B1.B2都继承自类A,因此在类D中两次出现类A中的变量和函数.为了节省内存空间,可以将B1.B2对A的继承定义为虚拟继承,而A就成了虚拟基类.实现的代码如下: class A class B1:public virtual A; class B2:public virtual A; class D:public B1,public B2; 虚拟继承在一般的应用中很少用到,

C++虚拟继承 类的内存布局

1. 单个虚拟继承 只是为了分析而已,实际中并没有太大的作用.跟虚拟继承相关的派生类对象的内存布局跟具体的编译器相关. (1)VS编译器:无论有无虚函数,必然含有虚基类表指针.虚基类表中的内容为本类实例的偏移和基类实例的相对偏移值.如果有虚函数,那么基类的虚函数表跟派生类的虚函数表是分开的. 在内存布局上,地址从低到高,顺序如下:派生类的虚函数表指针+虚基类表指针+派生类的成员变量+"间隔"(4个字节)+基类的虚函数表指针+基类的成员变量.派生类跟基类实例的位置关系跟普通继承正好相反.

虚继承和虚函数继承

虚继承主要用于菱形 形式的继承形式 虚继承是为了在多继承的时候避免引发歧义, 比如类A有个就是a,B继承了A,C也继承了A,当D多继承B,C时,就会有歧义产生了,所以要使用虚拟继承避免重复拷贝. 虚函数继承是解决多态性的,当用基类指针指向派生类对象的时候,基类指针调用虚函数的时候会自动调用派生类的虚函数,这就是多态性,也叫动态编联 虚函数继承: class A { virtual void fun() {cout < <'A' < <endl;}; }; class B : pub

虚继承与虚函数继承

虚继承主要用于菱形 形式的继承形式. 虚继承是为了在多继承的时候避免引发歧义,比如类A有个就是a,B继承了A,C也继承了A,当D多继承B,C时,就会有歧义产生了,所以要使用虚拟继承避免重复拷贝.虚函数继承是解决多态性的,当用基类指针指向派生类对象的时候,基类指针调用虚函数的时候会自动调用派生类的虚函数,这就是多态性,也叫动态编联 虚函数继承:class A{    virtual void fun() {cout < <'A' < <endl;};};class B : publi

菱形虚拟继承&虚函数表&对象模型

菱形继承: Assitant的菱形继承对象模型 Assitant中有两份Person成员,存在二义性和数据冗余. 所以我们引出了虚拟继承. virtual虚继.不会在子类中创建父类成员,但是子类中可以引用,就像指针一样.主要用在菱形继承,也叫钻石继承. 虚拟继承对象模型 class Student : vitrual public Person class Teacher : virtual public Peraon 虚函数表 通过一块连续内存来存储虚函数的地址.这张表解决了继承.虚函数(重写

C++里的继承和多态（下）——单继承、多继承、菱形继承（含虚拟函数的继承）

1.带有虚函数的类 class Base { public:                  virtual void FunTest1()                 {                                 cout << "Base::FunTest1()" << endl;                 }                  virtual void FunTest2()                 

深入理解虚表之非虚拟继承及虚拟继承

非虚拟继承 [带虚函数的类] class Base { public: virtual void FunTest1() { cout<<"Base::FunTest1()"<<endl; } virtual void FunTest2() { cout<<"Base::FunTest2()"<<endl; } int _data1; }; int main() { Base b; b._data1 = 0x01; re

关于虚拟继承类的大小问题探索，VC++ 和 G++ 结果是有区别的

昨天笔试遇到个 关于类占用的空间大小的问题,以前没怎么重视,回来做个试验,还真发现了问题,以后各位笔试考官门,出题时请注明是用什么编译器. vc6/vc8 cl 和 Dev-C 的g++ 来做的测试: 上代码, 测试代码: #include <stdio.h>class A{public: int x;  int y; A() {  x = 1;     y = 2; }; void go() {  printf("A go()\n"); }    virtual void