深入探索C++对象模型-（四）data语义学

1. 在只有继承没有多态的情况下，子类是的内容就是父类加上子类特有的数据成员，例如，对于如下两个类，Point2d和Point3d，后者公有继承自前者，此时的数据布局如下所示：

在某些情况下，把一个类分解成多层，可能会导致类所占用空间的膨胀，例如，如下类，算上对齐操作大小为8 （4 + 1 + 1+1 +(1对齐)）：

而如果相同的数据（val，c1，c2，c3），被分散的放入继承体系之中，现在一个包含所有这些数据的类Concrete3的大小就膨胀到了16，这是因为上面的无继承的类设计中，只有一个字节被用来对齐，而此种继承体系之下，有9个字节被用来对齐：

这时的类的布局如下：

为什么不把Concrete2和Concrete3的数据填补到Concrete1用于对齐的空间中呢？原因时，在此种情况下，当发生Concrete1的复制操作时，会破坏Concrete2的内容：

2. 加入多态时的情况，例如，街上上述的例子，对于Point2d，现在加入几个虚函数，用以支持多态特性：

此时会带来额外的空间以及存取时间上的额外负担：

a. 虚函数表会被产生出来（virtual table）。

b. 每一个类对象中会加入一个指向上述虚表的指针（vptr）。

c. 加强构造函数，使之可以为vptr设定初值。

d. 加强析构函数，使之可以清除指向虚函数表的vptr。

此时的类的内存布局会增加一个指向虚表的指针（该指针可能放在头部也可能放在尾部）：

3. 多种继承的情况，在单继承中，可以看到，基类和子类的对象都是从相同的地址开始的，差异只是子类比较大，例如以下操作，

P3d p3d;
P2d* p = &p3d;

以基类指针指向子类指针并不需要修改地址，多重继承则不一样，因为第二个乃至后面的基类起始地址与对应基类的地址并不一样，例如对于如下继承体系以及对应的内存布局：

从上图看以看出，最左端基类（P2d和P3d）的起始地址和子类V3d是一样的，而之后的基类Vertex则和子类不一致，因此，对于如下对象和指针：

Vertex3d v3d;
Vertex* pv;
Point2d* p2d;
Point3d* p3d;

如下的赋值操作：pv = v3d; 需要内部转化为：pv = (Vertex*)(((char*)&v3d) + sizeof(Point3d));即需要偏移才可以指向子类中对应的该基类的部分，而对于如下赋值：p2d = &v3d;p3d = &v3d; 则不需要任何调整。

如果要存取第二个或者后继基类中的一个数据成员，并不需要额外负担，因为数据成员的位置在编译时期就固定了，因此存取只是一个简答的位移（offset）运算，并不需要额外成本。

4. 虚拟继承的情况，考虑如下继承体系，Vertex和Point3d虚拟继承自Point2d，Vertex3d共有继承(非虚继承)自Vertex和Point3d

a. 此时必须有在子类对象中安插指针指向虚基类，一种可能的布局如下，子类需要维护指向虚基类地址的指针，此种策略下，对于Point3d运算符：

void Point3d::operator+=(const Point3d& rhs)
{
    _x += rhs._x;
    _y += rhs._y;
    _z += rhs._z;
};

会内部转化为：

pPoint2d->_x += rhs.pPoint2d->_x;
pPoint2d->_y += rhs.pPoint2d->_y;
_z += rhs._z;

而对于一个子类和基类的转换：

Point2d* p2d = pv3d; //Vertex3d* pv3d

会被转化为（必须判断pv3d是否为空，否则可能导致不正确的赋值）：

Point2d* p2d = pv3d ? pv3d->pPoint2d : 0;

b. 另一种策略是将虚基类的偏移量（而不是地址）存入虚表中（以下例子中，虚表中的正值索引会索引到虚函数地址，负值索引会索引到虚基类偏移量），也就是与虚函数放到一个表中，针对上例，此种策略下可能的布局如下，此种策略下，上述+=运算符会被转化为：

(this + __vptr__Point3d[-1])->_x += (rhs + rhs.__vptr__Point3d[-1])->_x;
(this + __vptr__Point3d[-1])->_y += (rhs + rhs.__vptr__Point3d[-1])->_y;
_z += rhs._z;

对于

Point2d* p2d  = pv3d;

会转化为：

Point2d* p2d  = pv3d ？ pv3d + pv3d->__vptr__Point3d[-1] ： 0；

由于虚拟继承的存在带来了额外的负担以及高度的复杂性，所以，一般而言，“虚基类的最有效的运用形式就是：一个抽象的虚基类，没有任何数据成员。”

类B和类C通过虚继承的方式派生自类A，这两个对象的内存布局中，编译器在对象中添加了一个vbptr(virtual base pointer)指针，vbptr指向了一张表，这张表保存了当前的虚指针相对于虚基类的首地址的偏移量。类D派生与类B和类C，继承了两个基类的vbptr指针，并调整了vbptr与虚基类的首地址的偏移量,使得这种菱形问题在继承时只继承一份数据，并且解决了二义性的问题。

当使用虚继承时，虚基类是被共享的，也就是在继承体系中无论被继承多少次，对象内存模型中都只会出现一个虚基类的子对象。

1. 数据成员指针是指指向类数据成员的指针，其内容为对应数据成员在类对象中的偏移量，类型为A::*，例如，如下类：

class Point3d {
    public:
        virtual ~Point3d();
    protected:
        static Point3d origin;
        float x, y, z;
};

以下操作: &Point3d::z，将得到一个偏移值，其值最小为x和y大小的总和，或者是加上一个指针大小，这是因为类Point3d中存在虚函数，对应的类对象中就要有一个指向虚函数表的指针，该指针在类对象布局中，可能放在最前端，此时x，y，z的偏移分别为：4，8，12，也可能放在最末端，此时x，y，z的偏移分别为：0，4，8，然而实际取出来的值却并非是这样，这个值总是比实际大一，即1，5，9类似（在VS2015中测试并没有大一，猜测是编译器做了优化），之所以需要大一，是为了区分一个没有指向任何数据成员的指针和一个指向了第一个数据成员的指针，例如：

float Point3d::*p1 = 0;
float Point3d::*p2 = &Point3d::x;

注意取非静态数据成员的地址（静态数据成员不属于具体的类对象，故没有偏移量一说）和取绑定与真正类对象身上的数据成员的地址的区别，Point3d origin; &origin.z类型为float*而不是Point3d::*，相应的静态成员的类型也为float*。

指向数据成员的指针的使用方法：

float Point3d::*p2 = &Point3d::x;
Point3d point;
point.*p2 = 1//等价于point.x = 1
Point3d* p3d = &point;
p3d->*p2 = 2;//等价于p3d->x = 2

2. 多重继承的情况下，将第二个（或者后继）基类指针与一个和子类对象绑定的数据成员结合起来时，情况会变得复杂，例如：

此种情况下，必须要考虑Base1存在导致的Base2的偏移，注意判零：func1(bmp ? bmp + sizeof(Base1) : 0, pd );

本文从5段代码实例出发。通过类中类的普通继承，类的虚继承，类的多重继承，多个虚函数类的普通继承、虚继承与多重继承，几个交叉概念，具体的阐释了继承、虚函数与虚继承的基本概念。深入剖析了继承于虚继承的差别于联系。

【Exp.001-虚继承】

#include 

class A {
public:
    int a;
};//sizeof(A)=4

class B : virtual public A {
public:
　　int b;
};//sizeof(B)=4(A副本)+4(虚表指针)+4(自己变量)=12

class C : virtual public B {     
};//sizeof(c)= 12(B副本)+4(虚表指针) = 16，假设这里改为直接继承，那么sizeof(c)=12

int main() {
    printf("%d\n", sizeof(C));    
    return 0; 
}

解析：这里须要理解虚继承基类对派生类的空间大小的影响，理解虚指针在虚继承中为子类带来了哪些空间的改变。

【Exp.002-多重继承】

#include 

class A {
public:
    int a;
};//sizeof(A) = 4

class B : virtual public A {
};// sizeof(B) =4+4=8

class C : virtual public A {        
};//sizeof(C) =4+4=8

class D : public B, public C{       
};
//sizeof(D)=8+8-4=12 这里须要注意要减去4，由于B和C同一时候继承A，仅仅须要保存一个A的副本就好了，sizeof(D)=4(A的副本)+4(B的虚表)+4(C的虚表)=12

int main() {
    printf("%d\n", sizeof(D));
    return 0; 
}

解析：这里须要关注 class D 的数据空间大小，理解多重虚继承对派生类虚指针以及派生类空间的影响。

【Exp.003-普通继承（含有：空类、虚函数）】

class A   
{   
};  

class B   
{
    char ch;   
    virtual void func0()  {  } 
}; 

class C  
{
    char ch1;
    char ch2;
    virtual void func()  {  }  
    virtual void func1()  {  } 
};

class D: public A, public C
{   
    int d;   
    virtual void func()  {  } 
    virtual void func1()  {  }
};   

class E: public B, public C
{   
    int e;   
    virtual void func0()  {  } 
    virtual void func1()  {  }
};

int main(void)
{
    cout<<"A="<这里须要区分一下：
 
  
①没有继承的时候，存在虚函数则须要加上虚指针，假设有多个也仅仅须要加上一个，由于仅仅有一个虚指针；
 
  
②对于普通继承，类D和类E中自己的虚函数，大小为0，由于，它没有虚表。
 
  
③对于虚继承中。派生类中存在一个或多个虚函数的时候，它本身就有一个虚表，指向自己的虚表，所以要加4。
 
  
 
  
【Exp.004-虚继承（多重继承和虚函数）】
 
  
 
  
class CommonBase
{
    int co;
};// size = 4

class Base1: virtual public CommonBase          
{
public:
    virtual void print1() {  }
    virtual void print2() {  }
private:
    int b1;
};//4副本+4虚指针+4自身+4(虚继承+虚函数构成指针多一个)=16


class Base2: virtual public CommonBase        
{
public:
    virtual void dump1() {  }
    virtual void dump2() {  }
private:
    int b2;
};//同理16

class Derived: public Base1, public Base2     
{
public:
    void print2() {  }
    void dump2() {  }
private:
    int d;
};//16+16-4+4=32
 
  
解析：假设不是虚继承的类。即便有虚函数也不会因此添加存储空间，假设是虚继承的类。没有虚函数就加入一个虚指针空间，有虚函数不论多少个，就加入两个虚指针空间。
 
  
【Exp.005-虚继承与虚函数】
 
  
 
  
class A
{
public:
    virtual void aa() {  }
    virtual void aa2() {  }
private:
    char ch[3];
}; // 1+4 = 补齐 = 8

class B: virtual public A
{
public:
    virtual void bb() {  }
    virtual void bb2() {  }
}; // 8（副本）+4(虚继承)+4（虚指针） = 16

int main(void)
{
    cout<<"A's size is "<
 
  
解析：假设不是虚继承的类。即便有虚函数也不会因此添加存储空间。假设是虚继承的类。没有虚函数就加入一个虚指针空间，有虚函数不论多少个，就加入两个虚指针空间。
 
  
【小结】
 
  
重要的事情讲三遍！！
 
  
。
 
  
假设不是虚继承的类，即便有虚函数也不会因此添加存储空间。假设是虚继承的类。没有虚函数就加入一个虚指针空间，有虚函数不论多少个。就加入两个虚指针空间。。！