深度探索C++对象模型：4.Function语意学

第四章： Function语意学
Nonstatic Member Functions（非静态成员函数）

Point3d obj;

Point3d *ptr = &obj;

Point3d Point3d::normalize() const{

register float mag =magnitude();

Point3d normal;

normal._x = _x/mag;

normal._y = _y/mag;

normal._z = _z/mag;

return normal;

}

Point3d::magnitude() const {

return sqrt(_x*_x+_y*_y+_z*_z);

}
C++的设计准则之一就是：nonstaticmember function至少必须和一般的nonmember function有相同的效率。这是因为编译器内部已将“member函数实例”转换为对等的“nonmember函数实例”。

举个例子，下面是magnitude()的一个nonmember定义：

float magnitude3d(constPoint3d *_this)const {

return sqrt(_this->_x *_this->_x +

_this->_y*_this->_y +

_this->_z*_this->_z );

}

而我们的member function版本将按如下步骤转换：

1.改写函数的signature以安插一个额外参数（this指针）到member function中，结果如下：

Point3d Point3d::magnitude(const Point3d * constthis)

之所以有两个const，是因为第一个const表示magnitude函数具有const性质，第二个const表示this是const指针。

2.将每一个对nonstatic data member的存取操作改为由this指针存取，结果如下

{

return sqrt(this->_x*this->_x +

this->_y *this->_y+

this->_z *this->_z);

}

3.将member function重新写成一个外部函数，并将函数名称经过magling（所谓的Name Mangling是指在member的名称上加上class名称以及member function的signature）处理，使它成为在程序中独一无二的语汇：

extern magnitude_7Point3dFv(

register Point3d* constthis);

现在这个函数已经村换号，而其每一个调用也都必须转换，如下：

obj. magnitude ()变为magnitude_7Point3dFv（&obj）；

ptr-> magnitude()变为 magnitude_7Point3dFv（ptr）;

normalize()函数将会被转换为一下形式，其中假设NRV可行：

void normalize_7Point3dFv(registerconst Point3d*constthis, Point3d *_result){

register float mag = this->magnitude();

_result.Point3d::Point3d();

_result._x = this->_x/mag;

_result._y = this->_y/mag;

_result._z = this->_z/mag;

return;

}

Virtue Member Function(虚拟成员函数)

如果normalize()是一个虚拟成员函数，那么下面的调用

ptr->normalize();

将会被内部转化为

( * ptr->vptr[ 1 ])( ptr );

其中：

Vptr表示右边一起产生的指针，指向virtual table。

1是virtual table slot的索引值，关联到normalize()；

第二个ptr表示this指针。

但对于以下调用：

Obj.normalize();

上述调用的函数实例只可以是Point3d::normalize()，所以编译器会将它转化如下：

Normalize_7Point3dFv( &obj );

像上面经由一个class object调用一个虚函数，这种操作应该总是被编译器对待一般的nonstaticmember function一样加以决议。

Static Member Function(静态成员函数)

如果Point3d::normalize()是一个static memberfunction，一下两个调用：

obj.normalize();

ptr->normalize();

将被转换为一般的nonmember函数调用，像这样：

normalize_7Point3dSFv();

normalize_7Point3dSFv();

独立于class object之外的存取class object的static data member操作主要有两种方法：如下

1.程序上的解决之道是将0强制转换为一个class指针，因而提供一个this指针实例，如下面这个例子：

class Point3d{

public:

int object_count(){

cout<< x << endl;

return x;

}

private:

static intconst x = 5;

};

int main(){

((Point3d*)0 )->object_count();

return 0;

}

结果输出5.

2.语言层面上的解决之道，引入static member function。Static member function的主要特性就是它没有this指针。以下次要特性统统根源于主要特性：

1)他不能够直接存取其class中的nonstaticmembers

2)他不能够被声明为const、volatile或virtual

3)它不需要经由class object才被调用---虽然大部分时候它是这样被调用的

取一个static member function的地址，获得的将是其在内存中的位置，也就是其地址。由于static member function没有this指针，所以其地址的类型是一个nonmember函数指针，并不是指向class member function的指针。

Static member function由于缺乏this指针，因此差不多等同于nonmember function。

4.2 virtual member functions虚拟成员函数

Virtual function的一般实现模型（无继承）：每一个class有一个virtual table，内含class之中有作用的virtual function的地址，然后每个object有一个vptr，指向virtual table的存在。这一节会讨论单一继承，多重继承和虚拟继承这三种情况。

单一继承：

在编译时期：会准备好虚函数的地址值存放在虚函数表中，并且表中的这组地址是固定不变的，表本身的大小也不会改变；为了找到表格会为每个class object安插一个指针指向该表格。

执行期要做的是在特定的virtual table slot中激活virtual function。

在单一继承中，一个class只会有一个virtual table。每一个table内含其对应 的class object中所有的activate virtual function函数实例的地址。这些activevirtual function包括：

1）这一class所定义的函数实例。它会改写一个可能存在的baseclass virtual function函数实例。

2）继承自base class的函数实例

3）一个pure_virtual_called()函数实例。

举例如下：

class Point{

public:

virtual ~Point();

virtual Point& mult( float) = 0;

float x() const { return _x; }

virtual float y() const { return 0;}

virtual float z() const { return 0;}

protected:

Point( float x = 0.0; );

float _x;

};

它的内存布局和virtual table如下图所示：

如果有Point2d派生自Point如下：

class Point2d:public Point{

public:

Point2d( float x = 0.0, floaty = 0.0)

:Point(x),_y(y){}

~Point2d();

Point2d &mult(float);

float y() const {return _y;}

protected:

float _y;

};

一共有三种可能性：

1）他可能继承base class声明的virtualfunction的函数实例，则该函数实例的地址会被拷贝到derived class的virtual table的相应slot中。

2）它可能使用自己的函数实例，表示它自己的函数实例必须放在相应slot中。

3）它可能加入一个新的virtual function，这个时候virtual table的尺寸会增大一个slot，而新的函数实例会被放进slot中。

Point2d的内存布局和virtual table如上图所示。

类似的情况，Point3d派生自Point2d。

class Point3d:public Point2d{

public:

Point3d( float x = 0.0, floaty = 0.0, float z =0.0)

:Point2d(x,y),_z(z){}

~Point3d();

Point3d &mult(float);

float z() const {return _z;}

protected:

float _z;

};

Point3d的内存布局和virtual table如上图所示。

现在如果有这样的式子：

ptr->z();

一般而言，每次调用z()时，并不知道ptr所指对象的真正类型，但是可以知道经由ptr可以存取到该对象的virtual table，可以知道每一个z()函数地址被放在slot 4中。所以编译器可以将该调用转化为：

（*ptr->vptr[ 4 ] ）( ptr );

在这一转换中，唯一在执行期才能知道的东西是：slot 4所指的到底是哪一个z()函数实例。

多重继承下的virtual function

已知如下多重继承

class Base1{

public:

Base1( );

virtual voidspeakClearly(){};

virtual Base1* clone( ) const{};

protected:

float data_Base1;

};

class Base2{

public:

Base2( );

virtual void mumble(){};

virtual Base2* clone( ) const{};

protected:

float data_Base2;

};

class Derived:public Base1,public Base2{

public:

Derived( ){};

virtual Derived* clone( ) const{};

protected:

float data_Derived;

};

“Derived支持virtual functions”的困难度，统统落在Base2 subobject身上。有三个问题需要解决。

1）virtual destructor

2）被继承下来的Base2::mumble()

3）一组clone()函数实例

首先，我们把一个从heap中配置而得的Derived对象的地址，指定给一个Base2指针：

Base2* pbase2=new Derived;

新的Derived对象的地址必须调整，以指向其Base2 subobject。编译时期会产生以下的代码：

Derived* temp=new Derived;

Base2* pbase2=temp?temp+sizeof(Base1):0;

如果没有这样的调整，指针的任何“非多态运用”（像下面那样）都将失败：

//即使pbase2被指定一个Derived对象，这也应该没有问题

Pbase2->data_Base2;

当程序员要删除pbase2所指的对象时：

//必须首先调用正确的virtual destructor函数实体

//然后施行delete运算符

//pbase2可能需要调整，以指出完整对象的起始点

Delete pbase2;

指针必须被再一次调整，以求再一次指向Derived对象的起始处（推测它还指向Derived对象）。然而上述的offset加法却不能够在编译时期直接设定，因为pbase2所指向的真正对象只有在执行期才能确定。

一般规则是，经由指向“第二或后继之base class”的指针（或reference）来调用derived class virtual function。

//如下例一样

Base2 *pbase2=new Derived;

...

Delete pbase2;

该调用操作所连带的“必要的this指针调整”操作，必须在执行器完成。也就是说，offset的大小，以及把offset加到this指针上头的那一小段程序代码，必须由编译器在某个地方插入。问题是，在那个地方？

Bjame原先实施与cfront编译器中的方法是将virtualtable加大，使它容纳此处所需的this指针，调整相关事物。每一个virtual table slot，不再只是一个指针，而是一个聚合体，内含可能的offset以及地址。于是virtual function的调用操作由：

（*pbase2->vptr[1])(pbase2);

改变为：

(*pbase2->vptr[1].faddr)

(pbase2+pbase2->vptr[1].offset);

其中faddr内含virtualfunction地址，offset内含this执政调整值。

这个做法的缺点是，它相当于连带处罚了所有的virtual function调用操作，不管它们是否需要offset的调整。

比较有效的方法是利用所谓的thunk。

所谓thunk是一小段assembly代码，用来(1)以适当的offset值调整this指针，（2）跳到virtual function去。例如，经由一个Base2执政调用Derived destructor,其相关的thunk可能看起来是这个样子：

Pbase2_dtor_thunk:

This+=sizeof(base1); //总感觉这里应该是this-=sizeof(base1) ???

Derived::~Derived(this);

Thunk技术允许virtual table slot继续内含一个简单的指针，因此多重继承不需要任何空间上的额外负担。Slots中的地址可以直接指向virtual function,也可以指向一个相关的thunk（如果需要调整this指针的话）。于是，对于那些不需要调整this指针的virtual function而言，也就不需承载效率上的额外负担。

调整this指针的第二个额外负担就是，由于两种不同的可能：（1）经由derived class（或第一个base class）调用，（2）经由第二个（或其后继）base class调用，同一函数在virtual table中可能需要更多笔对应的slots。例如：

Base1* pbase1=new Derived;

Base2* pbase2=new Derived;

Delete pbase1;

Delete pbase2;

虽然两个delete操作导致相同的Derived destructor，但它们需要两个不同的virtual tableslots:

1、pbase1不需要调整this指针（因为Base1是最左端base class之故，它已经指向 Derived对象的起始处）。其virtual table slot需放置真正的destructor地址。

2、Pbase2需要调整this指针。其virtual table slot需要相关的thunk地址。

在多重继承之下，一个derived class内含n-1个额外的virtual tables,n表示其上一层base classes的数目（因此，单一继承将不会有额外的virtual tables)。对于本例之Derived而言，会有两个virtual tables被编译器产生出来：

1、一个主要实体，与Base1共享。

2、一个次要实体，与Base2有关。

针对每一个virtual tables,Derived对象中有对应的vptr。Vptrs将在constructor(s)中被设立初值（经由编译器所产生出来的代码）。

用以支持“一个class拥有多个vritualtables”的传统方法是，将每一个tables以外部对象的形式产生出来，并给予独一无二的名称。例如，Derived所关联的两个tables可能有这样的名称：

Vtbl__Derived:

Vtbl__Base2__Derived;

于是当你将一个Derived对象地址指定给一个Base1指针或Derived指针时，被处理的virtual table是主要表格vtbl__Derived。而当你将一个Derived对象地址指定给一个Base2指针时，被处理的virtual table是次要表格vtbl_Base2_Derived。

开节之前，我们曾提到有三种情况会影响对virtual functions的支持。

第一种情况是，通过一个“指向第二个base class”的指针，调用derived class virtualfunction。例如：

Base2 *ptr=new Derived;

//调用Derived::~Derived

//ptr必须被向后调整sizeof(Base1)个bytes

Delete ptr;

从图4.2之中，你可以看到这个调用操作的重点：ptr指向Derived对象中的Base2 subobject;为了能够正确执行，ptr必须调整指向Derived对象的起始处。

第二种情况是第一种情况的变化，通过一个“指向derived class”的指针，调用第二个base class中一个继承而来的virtual function。在此情况下，derived class指针必须再次调整，以指向第二个base subobject。例如：

Derived* pder=new Derived;

//调用Base2::mumble( )

//pder必须被向前调整sizeof(Base1)个bytes

Pder->mmble( );

第三种情况发生于一个语言扩充性质之下，允许一个virtual function的返回值类型有所变化，可能是base type，也可能是public derived type。这一点可以通过Derived::clone( )函数实体来说明。Clone函数的Derived版本传回一个Derived class指针，默默地改写了它的两个base class函数实体。当我们通过“指向第二个base class”的指针来调用clone（ ）时，this指针的offset问题于是诞生：

Base2* pb1=new Derived;

//调用Derived* Derived::clone( )

//返回值必须被调整，以指向Base2 subobject

Base2 *pb2=pb1->clone( );

当进行pb1->clone( )时，pb1会被调整指向Derived对象的起始地址，于是clone( )的Derived版会被调用；它会传回一个指针，指向一个新的Derived对象；该对象的地址在被指定给pb2之前，必须先经过调整，以指向Base2 subobject。

虚拟继承下的virtual functions

考虑下面的virtual base class派生体系，从Point2d派生出Point3d:

class Point2d{

public:

Point2d(float=0.0,float=0.0);

virtual ~Point2d( );

virtual void mumble();

virtual float z( );

//...

protected:

float _x,_y;

};

class Point3d:publicvirtual Point2d{

public:

Point3d(float=0.0,float=0.0,float=0.0);

~Point3d( );

float z( );

protected:

float _z;

};

虽然Point3d有唯一一个baseclass,也就是Point2d,但Point3d和Point2d的起始部分并不像“非虚拟的单一继承”情况那样一致。由于Point2d和Point3d的对象不再相符，两者之间的转换也就需要调整this指针。至于在虚拟继承的情况下要清除thunks,一般而言已经被证明是一项高难度技。

指向Member Function的指针

取一个nonstatic memberfunction的地址，如果该函数是nonvirtual,得到的结果是它在内存中真正的地址，然而这个值也不是完全的。它也需要被绑定于某个class object的地址上，才能够通过它调用函数。所有的nonstaticmember function都需要对象的地址。

一个指向member function的指针，其声明语法如下：

Double //函数返回类型

(Point::* //类的名称，::符号，以及*符号

pmf) //指针名称

(); //函数的参数列表

然后我们可以这样定义并初始化该指针：

Double（Point::*coord）() = &Point::x;

也可以赋值：

Coord =&Point::y;

欲调用它，可以这么做：

(orgin.*coord)();

Ptr->(*coord)();

这些操作会被编译器转换如下：

(coord)(&origin);

(coord)(ptr);

支持指向virtual memberfunction的指针

多态仍然运行，举例如下：

float(Point::* pmf)() = &Point::z;

Point *ptr = new Point3d;

(ptr->*pmf)();//被调用的是Point3d::z()

然而面对一个virtual function，其地址在编译时期是未知的，所能知道的仅是virtualfunction在其相关的virtual table中的索引值。也就是说，对一个virtual table function取其地址，所能获得只是一个索引值。例如，假设我们有以下Point声明

class Point{

public:

virtual ~Point();

float x();

float y();

virtual float z();

}

取其destructor的地址：&Point::~Point得到的结果是1。取x()或y()的地址得到的是函数在内存中的地址，因为他们不是virtual。取z()的地址得到的是2。通过pmf来调用z()，会被转换如下：

（*ptr->vptr[(int)pmf]）(ptr);

所以pmf的内部定义必须允许能够判断出两种不同类型，因为nonvirtual的函数指针为内存地址而virtual函数指针为索引值。

在多重继承之下：指向MemberFunction的指针

为了让指向member function的指针能支持多重继承和虚拟继承，stroustup设计了下面的结构体：

struct _mptr{

int delta;

int index;

union{

ptrtofunc faddr;

int v_offset;

};

};

Index和faddr分别持有virtualtable索引和nonvirtual member function地址。在此模型下，像这样的调用操作：

（ptr->*pmf）();

会变成：

(pmf.index<0) ?

(*pmf.faddr)(ptr) :

(*ptr->vptr[pmf.index](ptr));

而microsoft导入所谓的vcall thunk。在此策略下，faddr被指定的要不就是真正的member function地址，要不就是vcall thunk的地址。于是virtual或nonvirtual函数的调用操作透明化，vcall thunk会选出并调用相关的virtual table中的适当slot。