深度探索C++对象模型 3Data语意学

第三章 Data语意学

已知如下程序：

#include<iostream>
using namespace std;
class X{};
class Y:
public virtual X{};
class Z:
public virtual X{};
class A:
public Y,public Z{};

int main(){
cout << sizeof(X) << endl;
cout << sizeof(Y) << endl;
cout << sizeof(Z) << endl;
cout << sizeof(A) << endl;
return 0;
}

在VS2008上执行结果如下：



一个空的class如X，事实上不是空的。因为空类也可以被实例化，就必须被分配内存，所以编译器默认分配给他一个字节（安插进去了一个char，故大小为1byte）以便标记初始化的类实例，同时使空类占用的空间也最少。

Y和Z的大小受到三个因素的影响：

1. 语言本身所造成的额外负担：当语言支持virtual base classes或virtualfunction时，就会造成额外负担。这里Y和Z上都增加了一个指针（大小为4bytes），指向virtual base class X subobject。

2. 编译器对于特殊情况所提供的优化处理：有些传统编译器会将virtual base class X subject的1byte大小放在X和Y上，而有些编译器（如VS2008，VC++ 6.0）因为Y和Z已经有一个指针的大小指向virtual baseclass X subject，可以认为Y和Z不是空类，就不需要编译器来生成1byte。

3. Alignment的限制：alignment就是将数值调整到某数的整数倍。在32位计算机上，通常是4bytes(32位)，以使bus的运输量达到最高效率。

所以Y和Z的大小在VS2008上为4字节。如下图所示：



而如果这段程序在传统编辑器上，则大小为8字节（4字节的指针+1字节+3字节的Alignment填充），如下图所示：


对于class A，在传统编辑器上大小由以下几点决定：

1. 被大家共享的唯一一个class X实例，大小为1byte。

2. Baseclass Y的大小，减去“因virtual base class X而配置”的大小，结果是4byte。Base classZ也一样。加起来是8bytes。

3. Class A自己的大小：0byte

4. Class A的alignment数量，前面三项加起来是9bytes，故需要填充4bytes。结果为12。

但在VS2008上，class X的1byte被拿掉，故无需额外的3byte填充，所以大小为8bytes。

C++ Stand并不强制规定如“base classsubject的排列顺序”或“不同存取层级的data members的排列顺序”，也不规定virtualfunction或virtual base class的实现细节，这些实现都由编译器产商自定。

在这一章，class的data members以及class hierarchy是中心议题。对于nonstaticdata member（不论是否继承而来）都放置于每一个class object中，但没有定义他们之间的排列顺序。至于staticdata member，则被放置在程序的一个global data segmen中，只存在一份实例，不会影响class object的大小。

3.1DataMember的绑定

//某个foo.h头文件，从某处含入
extern float x;
//程序员的Point3d.h文件
class Point3d{
public:
Point3d( float,float,float);
float X()
const{return x;}
void X(float new_x)const{x = new_x;}
private:
float x, y, z;
}

这里Point3d::X()返回的是class内部的x,但早期情况并不如此。和早期情况相似的是，现在的member function的argument list中的名称还是会在他们第一次遭遇决议时被适当的完成。如下所示：

#include<iostream>
#include
<string>
using namespace std;
typedef string length;
class Point3d{
public:
void mumble(length val){ _val = val ;}
length mumble(){return _val;}
void prif(){cout << _val;}
private:
typedef
float length;
length _val;
};
int main(){
Point3d p3;
return 0;
}
执行就会报错，原因是在两个member function signatures中length的类型都决议为global typedef,也就是string，不能将string转化为flaot或将flaot转化为string。
3.2Data Member的布局
Nonstaticdata members在class object中的排列顺序将和其被声明的顺序一样。C++Standard要求，在同一个access section（也就是private，protected，public）中，members排列顺序只要符合“较晚的members在class object中有较高的地址”这一条件就可以。也就是说各个members并不一定得连续排列。例如，members的边界调整（alignment）可能就需要补充一些bytes。此外，虽然目前的编译器不是把vptr放在class
object的最前端就是放在显示声明的members的最后，但是C++ Standard并没有要求，它允许编译器把那些内部产生出来的members(如vptr)自由放在任何位置。
class Point{
private:
float x;
float y;
private:
float z;
}
按C++Standard，在每个Point object中，x必须在y前面，但不一定必须在z前面。但目前编译器都是将z放在y之后。
3.3 Data Member的存取
已知类Point3d如下：
class Point3d{
public:
float x;
static list<Point3d*> *freeList;
public:
float y;
static
const int chunkSize;
public:
float z;
};
则
Point3d origin, *pt=&origin;
Origin.x=0.0;
Pt-x= 0.0;
通过origin与通过pt存取有什么重大差异？可从static和nonstatic Data Members两方面看。
Static Data Members
对于static data member（无论是否继承而来，是否是虚基类中），不管通过对象读取还是通过指向对象的指针读取，无差异。
如：origin. chunkSize = 250;内部会被转化为 Point3d::chunkSize= 250;
Pt-> chunkSize=250;同样也会被转化为Point3d::chunkSize= 250;

注意：若取一个static data member的地址，会得到一个指向其数据类型的指针，而不是一个指向其class member的指针，因为static member并不内含在一个class object中。例如：
&Point3d::chunkSize; //会获得如下地址const int*
Nonstatic Data Members
欲对一个nonstatic data member进行存取操作，编译器需要把class object的起始地址加上data member的偏移位置。举个例子：
如果
origin.y=0.0;
那么地址&origin.x将等于：
&origin+(&Pointd::y-1)
请注意其中的-1操作。指向data member的指针，其offset值总是被加上1，这样可以是编译器区分“一个指向data member的指着，用于指出class的第一个member”和“一个指向data member的指针，没有指出任何member”两种情况。如：
float Point3d::*p1 =0;//
这个就是“没有指向任何Data member”的指针
float Point3d::*p2 = &Point3d::x;//
这个就是指向x的“第一个Data member
//的指针”
每一个nonstatic data member的偏移位置在编译器即可获知，甚至如果member属于一个base class subobject也是一样。
但对于虚拟继承，将为“经由base class subobject”存取class members导入一层新的间接性，比如
Point3d*pt3d;
Pt->x= 0.0;、
其执行效率在x是一个struct member，classmember、单一继承，多重继承的情况下都完全相同。但如果x是一个virtual base class的member，存取速度会稍慢一点。
所以下面两式：
Origin.x=0.0;
Pt-x= 0.0;
当Point3d是一个derived class，而起继承结构中有一个virtual base class，并且被存取的member是一个从该virtual base class继承而来的member时，就会有重大差异。这时候我们不能说pt必然指向哪一种class type（因此我们也就不能知道编译器时期这个member真正的offet位置），所以这个存取操作必须延迟至执行期，经由一个额外的间接导引才能解决。但如果使用origin，其类型无疑是Point3d
class，而即使它继承自virtual base class，其member的offset位置也在编译期就固定了。
3.4“继承”与Data Member
在C++继承模型中，一个derived class object所表现的出来的东西，是其自己的members加上其base class members的总和。至于derived class members和base class members的排列顺序，则并未在C++ Standard中强制指定；理论上编译器可以自由安排之。在大部分编译器上头，base class members总是先出现，但属于virtual base class的除外（一般而言，任何一条通则一旦碰上virtual
base class就没辙了，这里也不例外）
定义一个class,没有虚函数，也没有继承，其数据分布和struct一模一样。
class Point2d{
public:
private:
float x,y;
};
class Point3d{
public:
private:
float x,y,z;
};
这节从单一继承且不含virtual function、单一继承并含virtual function、多重继承和虚拟继承四种情况讨论：
1. 单一继承且不含virtual function
class Point2d{
public:
Point(float x=0.0,floaty=0.0)
:_x(x),_y(y){};
float x(){return _x;}
float y(){return _y;}
void(float newX){_x=newX; }
void(float newY){_y=newY; }
void
operator+=(const Point2d &rhs){
_x += rhs.x();
_y += rhs.y();
}
protected:
float _x,_y;
};
class Point3d:publicPointed2d{
public:
Pointed(float x = 0.0,float y=0.0,
float z=0.0)
：Point3d(x,y),_z(z){};
float z(){
return_z;}
void z(float newZ){_z = newZ; }
void
operator+=(const Point3d &rhs){
Point2d::operator +=(rhs);
_z += rhs.z();
}
private:
float z;
};
布局如下：



一般而言具体继承（相对于虚拟继承）并不会增加空间或存取时间上的额外负担。但把一个class分解成两层或多层，有可能会为了“表现class体系抽象化”而膨胀所需要的空间。
如
class Concrete{
private:
int val;
char c1;
char c2;
char c3;
};
占用8bytes,其布局如下：



现在如果将Concrete分为三层结构如下：
class Concrete1{
private:
int val;
char bit1;
}
class Concrete2 :
publicConcrete1{
private:
char bit2;
}
class Concrete3 :
publicConcrete2{
private:
char bit3;
}
则这里Concrete3需要16bytes，其布局分布如下：



2. 单一继承并含virtual function
class Point2d{
public:
Point2d( float x=0.0,float y=0.0)
:_x(x),_y(y){};

virtual
float z(){return 0.0;}
virtual
void z(float){}

virtual
void operator +=(constPoint2d& rhs){
_x += rhs.x();
_y += rhs.y();
}

protected:
float _x,_y;
};
class Point3d:publicPointed2d{
public:
Pointed(float x = 0.0,float y=0.0,
float z=0.0)
：Point3d(x,y),_z(z){};
float z(){
return_z;}
void z(float newZ){_z = newZ; }
void
operator+=(const Point2d &rhs){//没有多态时，这里为constPoint3d &rhs
Point2d::operator +=(rhs);
_z += rhs.z();
}
private:
float z;
};
void foo(Point2d &p1,Point2d &p2){
p1 += p2;
}
以上foo函数中的参数p1和p2可能是2d也可能是3d，只是多态带来的弹性，但这对于Point2d class也带来了空间和时间上的额外负担：
1. 导入一个和Point2d有关的virtual table，用来存放它所声明的每一个virtual function的地址。这个table的元素个数一把是被声明的virtual function的个数加上一个或两个slots（用以支持runtime type identification）。
2. 在每个class object中导入一个vptr，提供执行期的链接，使每一个object能够找到相应的virtual table。
3. 加强constructor，使他能够成为vptr的初值，让他指向class所对应的virtual table。这意味着在derived class和每一个base class的constructor中，重新设定vptr的值。
4. 加强destructor，使他能够抹消“指向class的相关virtual table”的vptr。
在cfront编译器中，vptr被放在class object的尾端，用以支持下面的继承类型。
struct no_virts{
int d1,d2;
};
class has_virs:public no_virs{
public:
virtual
void foo();
private:
int d3;
};



到了C++2.0，某些编译器（如VC）把vptr放在了class object的起头处。如下图所示：



把vptr放在class object的前端，对于“在多重继承之下，通过指向class member的指针调用virtual function”会带来一些帮助。
这里我们的Point2d和Point3d的布局如下（如果把vptr放到尾部的话）：



3.多重继承
Point3dp3d;
Point2d*p = &p3d;
把一个derived class object指定给base class的指针或引用，这个操作不需要要编译器去调停或修改地址，会很自然的发生。但如果base class没有virtual function，而derived class有，那么单一继承的自然多态就会被打破。这种情况下，把一个derived object转换为其base类型，就需要编译器介入，用以调整地址（因为vptr的插入之故）。在既是多重继承有事虚拟继承的情况下，编译器的介入更有必要。
如：
class Point2d{
public:
//。。译注：拥有virtual接口，所以Point2d对象之中会有vptr
protected:
float _x,_y;
};
class Point3d:public Point2d{
public:
//...
private:
float _z;
};
class Vertex{
public:
//...译注：拥有virtual接口，所以Vertex对象之中会有vptr
private:
Vertex *next;
};
class Vertex3d:public Point3d,public Vertex{
public:
//...
private:
float mumble;
};
对于一个多重派生对象，将其弟子指定给“最左端base class的指针”，情况将和单一继承时相同，因为两者都指向相同的起始地址。需付出的成本只有地址的指定操作而已。至于第二个或后继的base class的地址的指定操作，则需要将地址修改过：加上介于中间的base object subobject大小，例如：
Vertex3d v3d;
Vertex *pv;
Point2d *p2d;
Point3d *p3d;
那么下面这个指定操作：
pv=&v3d;
需要这样的内部转化：
pv = (Vertex *)(((char*)&v3d)+sizeof(Point3d));
而下面的指定操作：
p2d = &v3d;
p3d = &v3d;
都只需要简单的拷贝其地址就好。如果有两个指针如下：
Vertex3d *pv3d;
Vertex *pv;
那么下面的指定操作：
pv = pv3d;
不能够只是简单地被转换为：
pv = (Vertex *)(((char*)&v3d)+sizeof(Point3d))；
因为当pv3d为时，pv将获得sizeof(Point3d)的值，这是错误的！需要加一个条件测试，如下：
pv = pv3d ? (Vertex *)(((char*)&v3d)+sizeof(Point3d)):0;
关于Vertex3d的布局如下：



C++Standard并未要求Vertex3d中的base classes Pointed3d和Vertex有特定的排列顺序。但目前的编译器都根据声明顺序来排列他们。
如果要存取第二个base class中的一个data member，不需要付出额外的成本，因为members的位置在编译时就固定了，因此存取members只是一个简单的offset运算。
4.虚拟继承
多重继承的一个语意上的副作用就是，它必须支持某种形式的“shared subobject继承”。一般的实现方法如下所述：class如果内含一个或多个virtual base class subobject，将被分割成两个部分：一个不变区域和一个共享区域。不变区域中的数据，不管后继如何衍化，总是拥有固定的offset，所以这一部分数据可以直接被存取。至于共享区域，所表现的的就是virtual base class subobject。这一部分的数据，其位置会因为每次的派生操作而有变化，所以它们只可以被间接存取。各家编译器实现技术之间的差异就在于间接存取的方法不同。根据以下程序说明三种主流策略:
class Point2d{
public:
…
protected:
float _x,_y;
};
class Point3d:public
virtual Point2d{
public:
...
protected:
float _z;
};
class Vertex:public
virtual Point2d{
public:
...
protected:
Vertex *next;
};
class Vertex3d:public Vertex,public Point3d{
public:
...
protected:
float mumble;
};
一般布局是先安排好derived class的不变部分，然后再建立其共享部分。
存取class共享部分的方法1：cfornt编译器会在每一个derived class object中安插一些指针，每个指针指向一个virtual base class。要存取继承的来的virtual base class members可以通过相关指针间接完成。例如，一下Point3d运算符：
void Point3d::operator+=(
const Point3d &rhs ){
_x += rhs._x;
_y += rhs._y;
_z += rhs._z;
}
在cfront策略之下，这个运算符会被内部转换为：
_vbcPoint2d->_x += rhs._vbcPoint2d->x;
_vbcPoint2d->y += rhs._vbcPoint2d->y;
_z += rhs._z;
而一个derived class和一个base class的实例之间的转换，像这样：
Point2d *p2d = pv3d;
在cfront实现模型之下，会变成：
Point2d *p2d = pv3d ? pv3d->_vbcPoint2d : 0;
这个实现模型主要有两个缺点：
1） 每一个对象必须对其每一个virtualbase class 背负一个额外指针。
2） 由于虚拟继承串链的加长，导致间接存取层次的增加，而我们希望有固定的存取时间。
对于第二个问题，一些编译器经由拷贝操作取得所有的nested virtual base class指针，放到derived class object之中。
这个模型下的布局如下所示：



存取class共享部分的方法2: Microsoft编译器引入所谓的virtual base class table。每一个class object如果有一个或多个virtual base classes，就会由编译器安插一个指针，指向virtual base class table。至于真正的virtual base class指针则被放在表格中。
存取class共享部分的方法3: 是在virtual function table中放置virtual base class的offet。Virtual function table可由正值或负值来索引。如果是正值，很显然就是索引到virtual function；如果是负值，则是索引到virtual base class offsets。在这样的策略下，Point3d的operator+=运算符号被转换成一些形式：
(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;
这种方法的布局如下图（注意看图中数字表示的偏移量）：



经由一个非多态的class object来存取一个继承而来的virtual base class的member，像这样：
Pointorigin;
…
origin._x;
可以被优化为一个直接存取操作，就好像一个经由对象调用的virtual function调用操作一样，可以在编译时期被决议完成。但如果是用指向对象的指针或引用来存取一个继承而来的virtual base class的member，则如以上分析运作。
3.5对象成员的效率
虚拟继承会降低类数据成员的存取效率。
3.6指向Data Members的指针
已知：
class Point3d{
public:
virtual ~Point3d();
void
static show(){
printf("&Point3d::x = %p \n",&Point3d::x);
printf("&Point3d::y = %p \n",&Point3d::y);
printf("&Point3d::z = %p \n",&Point3d::z);
}
protected:
static Point3d origin;
float x,y,z;
};
则&Point3d::z；
上述操作将得到z坐标在class object中的偏移地址。最低限度为x和y的大小总和，然后vptr位置没有限制，故上诉操作的值要不就是8要不就是12。然而编译器为了区分一个“没有指向任何data member”的指针，和一个指向“第一个data member”的指针，会使data member的地址总是加1。也就是说上诉Point3d中的三个数据成员偏移地址要不是1,5,9就是5,9,13。
在如下测试程序中：
int main(){
Point3d::show();
return 0;
}
在VS2008上执行结果如下：



这里之所以显示为0,4,8的原因是vptr放在了class object的最前面，并且VS2008做了特殊处理，使执行结果不加1。但在某些编译器（如BCB3）上执行结果为5,9,D。

在如下操作中：
Point3d origin;
&Point3d::z;
& origin.z;
Point3d::z返回的是float Point3d::* 类型，而origin.z返回的是float* 类型。
但如果z为static data member那么上诉操作都返回的是float*类型。

#include
<iostream>
using namespace std;
struct Base1{int val1,val2;};
struct Base2{int val3;};
struct Derived:Base1,Base2{intvald;};
int main(){
printf("%p\n",&Base1::val1);
printf("%p\n",&Base1::val2);
printf("%p\n",&Base2::val3);
printf("%p\n",&Derived::val1);
printf("%p\n",&Derived::val2);
printf("%p\n",&Derived::val3);
printf("%p\n",&Derived::vald);
return 0;
}
以上程序的执行结果如下：



可能是由于VS2008做了特殊处理，导致&Derived::val3的值也为0，但是由于&Derived::vald值为12，表示在vald前面确实有val，val2和val3存在。