C++ 对象的内存布局(下)(转)

最新推荐文章于 2024-02-25 01:17:38 发布
最新推荐文章于 2024-02-25 01:17:38 发布
阅读量600 收藏
点赞数
分类专栏： C/C++用法类 文章标签： c++ fun gcc class null 语言

C++ 对象的内存布局(下)

 

陈皓

http://blog.csdn.net/haoel

 

 

＜＜＜点击这里查看上篇

 

重复继承
 

下面我们再来看看，发生重复继承的情况。所谓重复继承，也就是某个基类被间接地重复继承了多次。

 

下图是一个继承图，我们重载了父类的f()函数。

 

 

 

其类继承的源代码如下所示。其中，每个类都有两个变量，一个是整形（4字节），一个是字符（1字节），而且还有自己的虚函数，自己overwrite父类的虚函数。如子类D中，f()覆盖了超类的函数， f1() 和f2() 覆盖了其父类的虚函数，Df()为自己的虚函数。

 

class B

{

    public:

        int ib;

        char cb;

    public:

        B():ib(0),cb('B') {}

 

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

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

};

class B1 :  public B

{

    public:

        int ib1;

        char cb1;

    public:

        B1():ib1(11),cb1('1') {}

 

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

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

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

 

};

class B2:  public B

{

    public:

        int ib2;

        char cb2;

    public:

        B2():ib2(12),cb2('2') {}

 

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

        virtual void f2() { cout << "B2::f2()" << endl;}

        virtual void Bf2() { cout << "B2::Bf2()" << endl;}

       

};

 

class D : public B1, public B2

{

    public:

        int id;

        char cd;

    public:

        D():id(100),cd('D') {}

 

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

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

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

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

       

};

我们用来存取子类内存布局的代码如下所示：（在VC++ 2003和G++ 3.4.4下）

    typedef void(*Fun)(void);

    int** pVtab = NULL;

    Fun pFun = NULL;

 

    D d;

    pVtab = (int**)&d;

    cout << "[0] D::B1::_vptr->" << endl;

    pFun = (Fun)pVtab[0][0];

    cout << "     [0] ";    pFun();

    pFun = (Fun)pVtab[0][1];

    cout << "     [1] ";    pFun();

    pFun = (Fun)pVtab[0][2];

    cout << "     [2] ";    pFun();

    pFun = (Fun)pVtab[0][3];

    cout << "     [3] ";    pFun();

    pFun = (Fun)pVtab[0][4];

    cout << "     [4] ";    pFun();

    pFun = (Fun)pVtab[0][5];

    cout << "     [5] 0x" << pFun << endl;

   

    cout << "[1] B::ib = " << (int)pVtab[1] << endl;

    cout << "[2] B::cb = " << (char)pVtab[2] << endl;

    cout << "[3] B1::ib1 = " << (int)pVtab[3] << endl;

    cout << "[4] B1::cb1 = " << (char)pVtab[4] << endl;

 

    cout << "[5] D::B2::_vptr->" << endl;

    pFun = (Fun)pVtab[5][0];

    cout << "     [0] ";    pFun();

    pFun = (Fun)pVtab[5][1];

    cout << "     [1] ";    pFun();

    pFun = (Fun)pVtab[5][2];

    cout << "     [2] ";    pFun();

    pFun = (Fun)pVtab[5][3];

    cout << "     [3] ";    pFun();

    pFun = (Fun)pVtab[5][4];

    cout << "     [4] 0x" << pFun << endl;

 

    cout << "[6] B::ib = " << (int)pVtab[6] << endl;

    cout << "[7] B::cb = " << (char)pVtab[7] << endl;   

    cout << "[8] B2::ib2 = " << (int)pVtab[8] << endl;

    cout << "[9] B2::cb2 = " << (char)pVtab[9] << endl;

 

    cout << "[10] D::id = " << (int)pVtab[10] << endl;

    cout << "[11] D::cd = " << (char)pVtab[11] << endl;

 

程序运行结果如下：


 

GCC 3.4.4
 VC++ 2003
 
[0] D::B1::_vptr->

     [0] D::f()

     [1] B::Bf()

     [2] D::f1()

     [3] B1::Bf1()

     [4] D::f2()

     [5] 0x1

[1] B::ib = 0

[2] B::cb = B

[3] B1::ib1 = 11

[4] B1::cb1 = 1

[5] D::B2::_vptr->

     [0] D::f()

     [1] B::Bf()

     [2] D::f2()

     [3] B2::Bf2()

     [4] 0x0

[6] B::ib = 0

[7] B::cb = B

[8] B2::ib2 = 12

[9] B2::cb2 = 2

[10] D::id = 100

[11] D::cd = D
 [0] D::B1::_vptr->

     [0] D::f()

     [1] B::Bf()

     [2] D::f1()

     [3] B1::Bf1()

     [4] D::Df()

     [5] 0x00000000

[1] B::ib = 0

[2] B::cb = B

[3] B1::ib1 = 11

[4] B1::cb1 = 1

[5] D::B2::_vptr->

     [0] D::f()

     [1] B::Bf()

     [2] D::f2()

     [3] B2::Bf2()

     [4] 0x00000000

[6] B::ib = 0

[7] B::cb = B

[8] B2::ib2 = 12

[9] B2::cb2 = 2

[10] D::id = 100

[11] D::cd = D
 


 

下面是对于子类实例中的虚函数表的图：

 


 

 


我们可以看见，最顶端的父类B其成员变量存在于B1和B2中，并被D给继承下去了。而在D中，其有B1和B2的实例，于是B的成员在D的实例中存在两份，一份是B1继承而来的，另一份是B2继承而来的。所以，如果我们使用以下语句，则会产生二义性编译错误：

 

D d;

d.ib = 0;               //二义性错误

d.B1::ib = 1;           //正确

d.B2::ib = 2;           //正确


注意，上面例程中的最后两条语句存取的是两个变量。虽然我们消除了二义性的编译错误，但B类在D中还是有两个实例，这种继承造成了数据的重复，我们叫这种继承为重复继承。重复的基类数据成员可能并不是我们想要的。所以，C++引入了虚基类的概念。

 

 

钻石型多重虚拟继承
 

虚拟继承的出现就是为了解决重复继承中多个间接父类的问题的。钻石型的结构是其最经典的结构。也是我们在这里要讨论的结构：

 

上述的“重复继承”只需要把B1和B2继承B的语法中加上virtual 关键，就成了虚拟继承，其继承图如下所示：

 

 

 

 

上图和前面的“重复继承”中的类的内部数据和接口都是完全一样的，只是我们采用了虚拟继承：其省略后的源码如下所示：

 

class B {……};

class B1 : virtual public B{……};

class B2: virtual public B{……};

class D : public B1, public B2{ …… };

 

在查看D之前，我们先看一看单一虚拟继承的情况。下面是一段在VC++2003下的测试程序：（因为VC++和GCC的内存而局上有一些细节上的不同，所以这里只给出VC++的程序，GCC下的程序大家可以根据我给出的程序自己仿照着写一个去试一试）：

 

    int** pVtab = NULL;

    Fun pFun = NULL;

 

    B1 bb1;

 

    pVtab = (int**)&bb1;

    cout << "[0] B1::_vptr->" << endl;

    pFun = (Fun)pVtab[0][0];

    cout << "     [0] ";

    pFun(); //B1::f1();

    cout << "     [1] ";

    pFun = (Fun)pVtab[0][1];

    pFun(); //B1::bf1();

    cout << "     [2] ";

    cout << pVtab[0][2] << endl;

 

    cout << "[1] = 0x";

    cout << (int*)*((int*)(&bb1)+1) <<endl; //B1::ib1

    cout << "[2] B1::ib1 = ";

    cout << (int)*((int*)(&bb1)+2) <<endl; //B1::ib1

    cout << "[3] B1::cb1 = ";

    cout << (char)*((int*)(&bb1)+3) << endl; //B1::cb1

 

    cout << "[4] = 0x";

    cout << (int*)*((int*)(&bb1)+4) << endl; //NULL

 

    cout << "[5] B::_vptr->" << endl;

    pFun = (Fun)pVtab[5][0];

    cout << "     [0] ";

    pFun(); //B1::f();

    pFun = (Fun)pVtab[5][1];

    cout << "     [1] ";

    pFun(); //B::Bf();

    cout << "     [2] ";

    cout << "0x" << (Fun)pVtab[5][2] << endl;

 

    cout << "[6] B::ib = ";

    cout << (int)*((int*)(&bb1)+6) <<endl; //B::ib

    cout << "[7] B::cb = ";

 

其运行结果如下（我结出了GCC的和VC++2003的对比）：

 

GCC 3.4.4
 VC++ 2003
 
[0] B1::_vptr ->

    [0] : B1::f()

    [1] : B1::f1()

    [2] : B1::Bf1()

    [3] : 0

[1] B1::ib1 : 11

[2] B1::cb1 : 1

[3] B::_vptr ->

    [0] : B1::f()

    [1] : B::Bf()

    [2] : 0

[4] B::ib : 0

[5] B::cb : B

[6] NULL : 0
 [0] B1::_vptr->

     [0] B1::f1()

     [1] B1::Bf1()

     [2] 0

[1] = 0x00454310 ç该地址取值后是-4

[2] B1::ib1 = 11

[3] B1::cb1 = 1

[4] = 0x00000000

[5] B::_vptr->

     [0] B1::f()

     [1] B::Bf()

     [2] 0x00000000

[6] B::ib = 0

[7] B::cb = B
 

 

 

这里，大家可以自己对比一下。关于细节上，我会在后面一并再说。

 

下面的测试程序是看子类D的内存布局，同样是VC++ 2003的（因为VC++和GCC的内存布局上有一些细节上的不同，而VC++的相对要清楚很多，所以这里只给出VC++的程序，GCC下的程序大家可以根据我给出的程序自己仿照着写一个去试一试）：

 

    D d;

 

    pVtab = (int**)&d;

    cout << "[0] D::B1::_vptr->" << endl;

    pFun = (Fun)pVtab[0][0];

    cout << "     [0] ";    pFun(); //D::f1();

    pFun = (Fun)pVtab[0][1];

    cout << "     [1] ";    pFun(); //B1::Bf1();

    pFun = (Fun)pVtab[0][2];

    cout << "     [2] ";    pFun(); //D::Df();

    pFun = (Fun)pVtab[0][3];

    cout << "     [3] ";

    cout << pFun << endl;

 

    //cout << pVtab[4][2] << endl;

    cout << "[1] = 0x";

    cout <<  (int*)((&dd)+1) <<endl; //????

 

    cout << "[2] B1::ib1 = ";

    cout << *((int*)(&dd)+2) <<endl; //B1::ib1

    cout << "[3] B1::cb1 = ";

    cout << (char)*((int*)(&dd)+3) << endl; //B1::cb1

 

    //---------------------

    cout << "[4] D::B2::_vptr->" << endl;

    pFun = (Fun)pVtab[4][0];

    cout << "     [0] ";    pFun(); //D::f2();

    pFun = (Fun)pVtab[4][1];

    cout << "     [1] ";    pFun(); //B2::Bf2();

    pFun = (Fun)pVtab[4][2];

    cout << "     [2] ";

    cout << pFun << endl;

   

    cout << "[5] = 0x";

    cout << *((int*)(&dd)+5) << endl; // ???

 

    cout << "[6] B2::ib2 = ";

    cout << (int)*((int*)(&dd)+6) <<endl; //B2::ib2

    cout << "[7] B2::cb2 = ";

    cout << (char)*((int*)(&dd)+7) << endl; //B2::cb2

 

    cout << "[8] D::id = ";

    cout << *((int*)(&dd)+8) << endl; //D::id

    cout << "[9] D::cd = ";

    cout << (char)*((int*)(&dd)+9) << endl;//D::cd

 

    cout << "[10]  = 0x";

    cout << (int*)*((int*)(&dd)+10) << endl;

    //---------------------

    cout << "[11] D::B::_vptr->" << endl;

    pFun = (Fun)pVtab[11][0];

    cout << "     [0] ";    pFun(); //D::f();

    pFun = (Fun)pVtab[11][1];

    cout << "     [1] ";    pFun(); //B::Bf();

    pFun = (Fun)pVtab[11][2];

    cout << "     [2] ";

    cout << pFun << endl;

 

    cout << "[12] B::ib = ";

    cout << *((int*)(&dd)+12) << endl; //B::ib

    cout << "[13] B::cb = ";

    cout << (char)*((int*)(&dd)+13) <<endl;//B::cb

 

下面给出运行后的结果（分VC++和GCC两部份）

 

 

GCC 3.4.4
 VC++ 2003
 
[0] B1::_vptr ->

    [0] : D::f()

    [1] : D::f1()

    [2] : B1::Bf1()

    [3] : D::f2()

    [4] : D::Df()

    [5] : 1

[1] B1::ib1 : 11

[2] B1::cb1 : 1

[3] B2::_vptr ->

    [0] : D::f()

    [1] : D::f2()

    [2] : B2::Bf2()

    [3] : 0

[4] B2::ib2 : 12

[5] B2::cb2 : 2

[6] D::id : 100

[7] D::cd : D

[8] B::_vptr ->

    [0] : D::f()

    [1] : B::Bf()

    [2] : 0

[9] B::ib : 0

[10] B::cb : B

[11] NULL : 0
 [0] D::B1::_vptr->

     [0] D::f1()

     [1] B1::Bf1()

     [2] D::Df()

     [3] 00000000

[1] = 0x0013FDC4  ç 该地址取值后是-4

[2] B1::ib1 = 11

[3] B1::cb1 = 1

[4] D::B2::_vptr->

     [0] D::f2()

     [1] B2::Bf2()

     [2] 00000000

[5] = 0x4539260   ç 该地址取值后是-4

[6] B2::ib2 = 12

[7] B2::cb2 = 2

[8] D::id = 100

[9] D::cd = D

[10]  = 0x00000000

[11] D::B::_vptr->

     [0] D::f()

     [1] B::Bf()

     [2] 00000000

[12] B::ib = 0

[13] B::cb = B
 


 

 

关于虚拟继承的运行结果我就不画图了（前面的作图已经让我产生了很严重的厌倦感，所以就偷个懒了，大家见谅了）

 

在上面的输出结果中，我用不同的颜色做了一些标明。我们可以看到如下的几点：

 

1）无论是GCC还是VC++，除了一些细节上的不同，其大体上的对象布局是一样的。也就是说，先是B1（黄色），然后是B2（绿色），接着是D（灰色），而B这个超类（青蓝色）的实例都放在最后的位置。

 

2）关于虚函数表，尤其是第一个虚表，GCC和VC++有很重大的不一样。但仔细看下来，还是VC++的虚表比较清晰和有逻辑性。

 

3）VC++和GCC都把B这个超类放到了最后，而VC++有一个NULL分隔符把B和B1和B2的布局分开。GCC则没有。

 

4）VC++中的内存布局有两个地址我有些不是很明白，在其中我用红色标出了。取其内容是-4。接道理来说，这个指针应该是指向B类实例的内存地址（这个做法就是为了保证重复的父类只有一个实例的技术）。但取值后却不是。这点我目前还并不太清楚，还向大家请教。

 

5）GCC的内存布局中在B1和B2中则没有指向B的指针。这点可以理解，编译器可以通过计算B1和B2的size而得出B的偏移量。

 

 

结束语
C++这门语言是一门比较复杂的语言，对于程序员来说，我们似乎永远摸不清楚这门语言背着我们在干了什么。需要熟悉这门语言，我们就必需要了解C++里面的那些东西，需要我们去了解他后面的内存对象。这样我们才能真正的了解C++，从而能够更好的使用C++这门最难的编程语言。

 

在文章束之前还是介绍一下自己吧。我从事软件研发有十个年头了，目前是软件开发技术主管，技术方面，主攻Unix/C/C++，比较喜欢网络上的技术，比如分布式计算，网格计算，P2P，Ajax等一切和互联网相关的东西。管理方面比较擅长于团队建设，技术趋势分析，项目管理。欢迎大家和我交流，我的MSN和Email是：haoel@hotmail.com 

 

 

＜＜＜点击这里查看上篇

 

 

(转载时请注明作者和出处。未经许可，请勿用于商业用途)

 

更多文章请访问我的Blog: http://blog.csdn.net/haoel


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/haoel/archive/2008/10/15/3081385.aspx

gxj1680
关注
专栏目录
C++中virtual继承的深入理解
09-05
本篇文章是对C++中的virtual继承进行了详细的分析介绍，需要的朋友参考下
virtual继承
tianli1987917的博客
07-24 219
今天专门看了一下虚继承的东西，以前都没怎么用过，具体如下： 父类: class CParent { .... }; 继承类的声明比较特别： class CChild : virtual public CParent { .... } 请问，这个"virtual"是什么作用及含义？ -----------...
C++ 虚拟继承问题
The Laughing Uncle的博客
08-19 9654
文章目录前言为什么要有虚拟继承虚拟继承和普通继承的区别虚拟继承 sizeof() 问题 前言 本篇文章主要描述虚拟继承中内存分布情况，当然，可能会不太完全正确，希望大家多多指正 为什么要有虚拟继承 我们看下面一种情景： class A { public: int a; }; class B : public A { public: int b; }; class C : public A ...
C++ virtual 继承
weixin_48631463的博客
06-10 707
笔记
C++ 对象的内存布局(上)(转)
gxj1680的专栏
07-09 687
C++ 对象的内存布局(上) 陈皓http://blog.csdn.net/haoel  点击这里查看下篇＞＞＞前言 07年12月，我写了一篇《C++虚函数表解析》的文章，引起了大家的兴趣。有很多朋友对我的文章留了言，有鼓励我的，有批评我的，还有很多问问题的。我在这里一并对大家的留言表示感谢。这也是我为什么再写一篇续言的原因。因为，在上一篇文章中，我用了的示例都是非常简
C++ 内存对象布局
11-08
接下来我们将详细探讨不同情况下的对象内存布局。 ##### 1. **空类** 空类是指没有任何成员变量的类。尽管此类没有任何成员，但编译器会为它分配1字节的空间来确保对象唯一性，即每个空类的对象都占据至少1字节的...
C++对象内存布局[归类].pdf
10-11
C++对象内存布局 C++对象内存布局是指在C++编程语言中对象在内存中的存储结构和布局方式。了解C++对象的内存布局对于理解C++编程语言的对象模型和内存管理机制非常重要。 从内存布局的角度来看，C++对象可以分为三...
C++对象内存布局
05-01
### C++对象内存布局 #### 1. 最简单的类 在C++中，理解对象的内存布局对于深入学习语言特性非常关键。通过分析一个简单的类`CTest`，我们可以更好地了解对象是如何在内存中分配和组织的。 ##### 1.1.1 赋值语句...
C++virtual继承
GyafdxIs的专栏
11-22 550
C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。     关于虚函数的使用方法，我在这
C++ virtual继承
乐观进取　奋斗不止
09-28 2400
C++ virtual继承的另一种名称是菱形继承，主要目的是用于解决从不同类继承来的同名数据成员在内存中有不同的拷贝，造成数据不统一的 问题，以致于在进行类释放时造成内存泄漏。将共同的基类作为虚基类，这时从不同的路径继承过来的同名数据成员在内存中就只有一个拷贝，同 一个函数名也只有一个映射。这样不仅就解决了二义性问题，也节省了内存，避免了数据不一致的问题。 如下是实现格式： cla
C++类的virtual继承关系
junlon2006的博客
11-10 721
class X { public: void getX() { cout<<"getX"<<endl; } int i,j,k,m; }; class Y: virtual public X { public: void getY() { cout<<"getY"<<endl; } }; class Z:virtual public X { public: void
C++ 多态与虚函数表（三）—— 重复继承
行走
08-16 440
一、前言 个人笔记，不保证严谨和正确☺，如有错误还望指出！ 《C++ 多态与虚函数表（一）—— 单继承》 《C++ 多态与虚函数表（二）—— 多继承》 《C++ 多态与虚函数表（三）—— 重复继承》 《C++ 多态与虚函数表（四）—— 虚继承》 《C++ 多态与虚函数表（五）拓展—— 对象大小》 二、重复继承 2.1 类定义 class Base { public: long long ibase; Base ():ibase (10) {} virtu.
解释 C++ 中的虚拟继承（Virtual Inheritance）
最新发布
qiuyehuanghun的博客
02-25 1512
虚拟继承是 C++ 中的一种特殊的继承方式，用于解决多重继承中的菱形继承问题。解决菱形继承问题：菱形继承问题是指在多重继承中，由于某个派生类间接继承了多个相同的基类，从而导致对这些基类成员的访问出现二义性。总的来说，虚拟继承是 C++ 中用于解决多继承带来的菱形继承问题的一种机制，通过共享基类子对象的方式来避免派生类中出现多个相同基类子对象，保证了派生类对象对基类成员的访问不会出现二义性。共享基类子对象：在虚拟继承中，派生类的对象只包含一个共享的基类子对象，而不是每个直接基类的子对象都被派生类所包含。
C++ 继承的重复问题
03-02 5100
重复继承是指一个派生类多次继承同一个 基类，C++中允许出现重复继承。 解决继承的重复问题 解决继承的重复问题有两种方法：    —使用作用域分辨符来唯一标识并分别访问他们；    —将直接基类的共同基类设置为虚基类         》从不同的路径继承过来的该类成员在内存中             只拥有一个复制，这样就解决了同名成员的             唯一标识问题
C++ 对象的内存布局（重复继承）
Robin Hu的专栏
06-28 702
原文：http://blog.csdn.net/haoel/article/details/3081385 下面，让我们来看看重复继承中C++对象的内存布局的情况，假设有下面这样一个类的继承关系。 所谓重复继承，也就是某个基类被间接地重复继承了多次。  下图是一个继承图，我们重载了父类的f()函数。      其类继承的源代码如下所示。其中，每个类都有两个变量，一个
C++虚拟继承
L_yangliu的专栏
10-11 843
C++使用虚拟继承（Virtual Inheritance），使得派生类如果继承基类多次，但只有一份基类的拷贝在派生类对象中。 虚拟继承的语法： class 派生类: virtual 基类1，virtual 基类2，...，virtual 基类n{ ...//派生类成员声明 }; 也就是说当一个派生类类有多个基类，而这多个基类，基类1，基类2、、、又同时继承一个共同基类3，这样就会使派生
C++多重继承重复调用的解决
土豪gold的博客
03-02 2524
问题：C++多重继承重复调用的解决 本程序通过VC++ 6.0编译与测试，R为A,B的父类，A,B为C的父类，具体代码如下： 继承的示意图： //由于多重继承造成的重复调用实例 #include &lt;iostream&gt; using namespace std; //祖先类 class R { private: int r; public: R (int x=0):r(x...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值