C++中派生类对象的内存布局

主要从三个方面来讲:

  1 单一继承

  2 多重继承

  3 虚拟继承

1 单一继承

(1)派生类完全拥有基类的内存布局,并保证其完整性。

  派生类可以看作是完整的基类的Object再加上派生类自己的Object。如果基类中没有虚成员函数,那么派生类与具有相同功能的非派生类将不带来任何性能上的差异。另外,一定要保证基类的完整性。实际内存布局由编译器自己决定,VS里,把虚指针放在最前边,接着是基类的Object,最后是派生类自己的object。举个栗子:

class A
{
    int b;
    char c;
};
class A1 :public A
{
        char a;
};
int main()
{
    cout << sizeof(A) << " " << sizeof(A1) << endl;
    return 0;
}

  输出是什么?

  答案:

    8 12

  A类的话,一个int,一个char,5B,内存对齐一下,8B。A1的话,一个int,两个char,内存对齐一下,也是8B。不对吗?

  我说了,要保证基类对象的完整性。那么一定要保证A1类前面的几个字节一定要与A类完全一样。也就是说,A类作为内存补齐的3个字节也是要出现在A1里面的。也就是说,A类是这样的:int(4B)+char(1B)+padding(3B)=8B,A1类:int(4B)+char(1B)+padding(3B)+char(1B)+padding(3B)=12B。

(2)虚指针怎么处理?

  还是视编译器而定,VS是永远把vptr放在对象的最前边。如果基类中含有虚函数,那么处理情况与上边一样。可是,如果基类中没有虚函数而派生类有的话,那么如果把vptr放在派生类的前边的话,将会导致派生类中基类成分并不在最前边。这将带来什么问题呢?举栗:假设A不含虚,而A1含。

A *pA;
A1 obj_A1;
pA=&obj_A1;

  如果A1完全包含A并且A位于A1的最前边,那么编译器只需要把&obj_A1直接赋给pA就可以了。如果不是呢?编译器就需要把&obj_A1+sizeof(vptr)赋给pA了。

2 多重继承

  说结论:VS的内存布局是按照声明顺序排列内存。再举个栗子:

class point2d
{
public:
    virtual ~point2d(){};
    float x;
    float y;
};
class point3d :public point2d
{
    ~point3d(){};
    float z;
};
class vertex
{
public:
    virtual ~vertex(){};
    vertex* next;
};
class vertex3d :public point3d, public vertex
{
    float bulabula;
};


int _tmain(int argc, _TCHAR* argv[])
{
    cout << sizeof(point2d) << " " << sizeof(point3d) << " " << sizeof(vertex) << " " << sizeof(vertex3d) << endl;
    return 0;
}

  输出: 12 16 8 24。

  内存布局:

    point2d: vptr(4)+x(4)+y(4)=12B

    point3d: vptr+x+y+z=16B

    vertex: vptr+next=8B

    vertex3d: vptr+x+y+z+vptr+next+bulabula=28B

3 虚拟继承

(1)为什么要有“虚继承”这样的机制?

  简单讲,虚继承是为也防止“diamond”继承所带来的问题。也就是类A1、A2都继承于A,类B又同时继承于A1、A2。这样一来,类B中就有两份类A的成员了,这样的程序无法通过编译。我们改成这样的形式:

class A
{
public:
  int a;
  virtual ~A(); };
class A1 :public virtual A {
  int a1; };
class A2 :public virtual A {
  int a2; };
class B :public A1,public A2 {
  int b; };

  这样就能防止这样的事情发生。

(2)虚拟继承与普通继承的区别:

  普通继承使得派生类每继承一个基类便拥有一份基类的成员。而虚拟继承会把通过虚拟继承的那一部分,放在对象的最后。从而使得只拥有一份基类中的成员。虚拟对象的偏移量被保存在Derived类的vtbl的this指向的上一个slot。比较难理解。下面我给你个栗子。

(3)虚拟继承的内存布局:

  每个派生类会把其不变部分放在前面,共享部分放在后面。

上面四个类的大小是怎样的呢?

int _tmain(int argc, _TCHAR* argv[])
{
    cout << sizeof(A) << " " << sizeof(A1) << " " << sizeof(A2) << " " << sizeof(B) << endl;
    return 0;
}

  输出:8 16 16 28

  内存布局:

    A: vptr+a=8B

    A1: vptr+a1+vptrA+a=16B

    A2: vptr+a2+vptrA+a=16B

    A3: vptr+a1+vptrA2+a2+b+vptrA+a=28B

  上个草图:

  就是这样。

没有更多推荐了,返回首页