构造、解构、拷贝语意学(Semantics of Construction,Destruction, and Copy)
一般而言,class的data member应该被初始化,并且只在constructor中或是在class的其他member functions中指定初值。其他任何操作都将破坏封装性质,使class的维护和修改更加困难。
纯虚函数的存在(Presence of a Pure Virtual Function)
C++ 新手常常很惊讶地发现,一个人竟然可以定义和调用(invoke)一个pure virtual function:不过它只能被静态地调用(invoked statically),不能经由虚拟机制调用。例如,你可以合法地写下这段代码:
//定义pure virtual function但只能被静态地调用(invoked statically)
inline void Abstract_base::interface() const{
//请注意,先前曾声明这是一个pure virtual const
function
//...
}
inline void Concrete_derived::interface() const{
//静态调用(static invocation)
Abastract_base::interface();
//请注意,我们竟然能够调用一个pure virtual
function
//...
}
要不要这样做,全由class设计者决定。唯一的例外就是pure virtual destructor: class设计者一定要定义它。为什么? 因为每一个derived class destructor会被编译器加以扩展,以静态调用的方式调用其“每一个virtual base class”以及“上一层base class”的destructor。因此,只要缺乏任何一个base class destructor的定义,就会导致链接失败。
“无继承”情况下的对象构造
考虑下面的程序片段:
(1) Point global;
(2)
(3) Point foobar()
(4) {
(5) Point local;
(6) Point *heap = new Point;
(7) *head = local;
(8) //... stuff ...
(9) delete heap;
(10) return local;
(11) }
L1,L5,L6表现出三种不同的对象产生方式:global内存配置、local内存配置和heap内存配置。L7把一个class object指定给另一个,L10设定返回值,L9则明确地以delete运算符删除heap object.
一个object的生命,是该object的一个执行期属性。local object的声明从L5的定义开始,到L10为止。global object的生命和整个程序的生命相同。heap object的生命从它被new运算符配置出来开始,到它被delete运算符摧毁为止。
下面是Point的第一次声明,可以写成C程序,C++ standard说这是一种所谓的Plain old Data声明形式:
typedef struct{
float x, y, z;
}Point;
如果以C++ 来编译这段码,会发生什么事? 观念上,编译器会为Point声明一个trivial default constructor、一个trivial destructor、一个trivial copy constructor,以及一个trivial copy assignment operator。但实际上,编译器会分析这个声明,并为它贴上Plain of Data标签
当编译器遇到这样的定义:
(1) Point global;
时,观念上Point的trival constructor和destructor都会被产生并被调用,constructor在程序起始(startup)处被调用而destructor在程序的exit()处被调用。然而,事实上那些tirvial members要不是没被定义,就是没被调用,程序的行为一如它在C中的表现一样。
只有一个小小的例外,在C中,global被视为一个“临时性的定义”,因为它没有明确的初始化操作。一个“临时性的定义”可以在程序中发生多次,那些实例会被链接器折叠起来,只留下单独一个实体,被放在程序data segment中的一个“特别保留给未初始化之global objects使用”的空间,由于历史的缘故,这段空间被称为BSS,这是Block Started by Symbol的缩写。
C++ 并不支持“临时性的定义”,这是因为class构造行为的隐含应用之故。因此,global在C++ 中被视为完全定义(它会阻止第二个或更多个定义)。C和C++的一个差异就在于,BSS data segment在C++中相对地不重要。C++ 的所有全局对象都被当作“初始化过的数据”来对待。
foobar() 函数中的L5,有一个Point object local,同样也是既没有被构造也没有被解构。当然啦,Point object local如果没有先经过初始化,可能会成为一个潜在的程序臭虫——万一第一次使用它就需要其赋初值的话(如L7)。至于heap object在L6的初始化操作:
(6) Point *heap = new Point;
会被转换为对new运算符的调用:
Point *heap = _new(sizeof(Point));
再一次强调,并没有default constructor施行与new运算符所传回的Point object身上。L7对此object有一个赋值(赋值,assign)操作,如果local曾被适当地初始化过,一切就没有问题:
(7) *heap = local;
事实上这一行会产生编译警告如下:
warning,line 7, local is used before being initialized
观念上,这样的指定操作会触发trivial copy assignment operator进行拷贝搬运操作。然而实际上此object是一个Plain old data,所以赋值操作(assignment)将只是像C那样的纯粹位搬移操作。L9执行一个delete操作:
(9) delete heap;
会被转换为对delete运算符(由library提供)的调用:
_delete(heap);
观念上,这样的操作会触发Point的trivial destructor。但是一如我们所见,destructor要不是没有被产生就是没有被调用。最后,函数以传值(by value)的方式将local当作返回值传回,这在观念上会触发trivial copy constructor,不过实际上return操作只是一个简单的位拷贝操作,因为对象是一个Plain old data。
抽象数据类型(Abstract Data Type)
以下是Point的第二次声明,在public接口之下多了private数据,提供完整的封装性,但是没有提供virtual function:
class Point{
public:
Point(float x = 0.0, float y = 0.0, float z = 0.0)
: _x(x), _y(y), _z(y) { }
//no copy constructor, copy operator or destructor defined
private:
float _x, _y, _z;
};
这个经过封装的Point class,其大小并没有改变,还是三个连续的float。是的,不论private、public存取层,或是member function的声明,都不会占用额外的对象空间。
对于一个global实体:
Point global; //实施Point::Point(0.0, 0.0, 0.0)
现在有了default constructor作用于其上。由于global被定义在全局范畴中,其初始化操作将延迟到程序激活(startup)时才开始。
如果要对class中的所有成员都设定常量初值,那么给予一个explicit initialization list会比较高效(比起意义相同的constructor的inline expansion而言)。甚至在local scope中也是如此。举例如下:
void mumble(){
Point local1 = {1.0, 1.0, 1.0};
Plint local2;
//相当于一个inline expansion, explicit initialization会稍微快一些
local2._x = 1.0;
local2._y = 1.0;
local2._z = 1.0;
}
local1的初始化操作会比local2的高效,这是因为当函数的activation record被放进程序堆栈时,上述initialization list中的常量就可以被放进local1内存中了。
Explicit initialization list带来三项缺点:
- 只有当class members都是public,此法才奏效
- 只能指定常量,因为它们在编译时期就可以被评估求值(evaluated)
- 由于编译器并没有自动施行之,所以初始化行为的失败可能性会高一些
在编译器层面,会有一个优化机制用来识别inline constructors,后者简单地提供一个member-by-member的常量指定操作。然后编译器会抽取出那些值,并且对待它们就好像是explicit initialization list所供应的一样,而不会把constructor扩展成一系列的assignment指令。
local Point object的定义如下:
{
Point local;
//...
}
现在被附加上default Point constructor的inline expansion:
{
//inline expansion of default constructor
Point local;
local._x = 0.0, local._y = 0.0, local._z = 0.0;
//...
}
L6配置出一个heap Point object:
(6) Point *heap = new Point;
现在则被附加一个“对default Point Constructor的有条件调用操作”:
Point *heap = _new(sizeof(Point));
if(heap != 0)
heap->Point::Point();
然后又被编译器进行inline expansion操作,至于把heap指针指向local object:
(7) *heap = local;
则保持简单的位拷贝操作,以传值方式传回local object,情况也是一样:
(10) return local;
L9删除heap所指之对象:
(9) delete heap;
该操作并不会导致destructor被调用,因为我们并没有明确地提供一个destructor函数实体。
观念上,我们的Point class有一个相关得default copy constructor,copy operator和destructor,然而它们都是无关痛痒的(trivial),而且编译器实际上根本没有产生它们。
为继承做准备
以下是第三个Point声明,将为“继承性质”以及某些操作的动态决议(dynamic resolution)做准备,当前我们限制对z成员进行存取操作:
class Point{
public:
Point(float x = 0.0, float y = 0.0)
: _x(x), _y(y) { }
//no destructor, copy constructor or copy operator
virtual float z();
protected:
float _x, _y;
};
再次强调,没有定义一个copy constructor、copy operator、destructor。我们所有的memebers都以数值来存储,因为在程序层面的默认语意之下,行为良好。
virtual function的引入促使每一个Point object拥有一个virtual table pointer。这个指针提供给我们virtual接口的弹性,代价是:每一个object需要额外的一个word空间。
除了每一个class object多负担一个vptr之外,virtual function的引入也引发编译器对于我们的Point class产生膨胀作用:
我们所定义的constructor被附加了一些码,以便使vptr初始化。这些码必须附加在任何base class constructors的调用之后,但必须在任何由使用者(程序员)供应的码之前。如:
```cpp
Point* Point::Point(Point *this, float x, float y)
: _x(x), _y(y){//设定object的virtual table pointer this->_vptr_Point = _vtbl_Point; //扩展member initialization list this->_x = x; this->_y = y; //传回this对象 return this;
}
```合成一个copy constructor和一个copy assignment operator,而且其操作不再是trivial(但implicit destructor仍然是trivial)。如果一个Point object被初始化或以一个derived class object赋值,那么以位为基础(bitwise)的操作可能会给vptr带来非法设定。
```cpp
//copy constructor的内部合成
inline Point* Point::Point(Point* this, const Point& rhs){
//设定object的virtual table pointer(vptr)
this->_vptr_Point = _vtbl_Point;//将rhs坐标中的位连续拷贝到this对象 //或是经由member assignment提供一个member... return this;
}
```
编译器在优化状态下可能会把object的连续内容拷贝到另一个object身上,而不会实现一个精确地“以成员为基础(memberwise)”的赋值操作。C++ Standard要求编译器尽量延迟nontrivial members的实际合成操作,直到真正遇到其使用场合为止。
一般而言,如果你的设计之中有许多函数都需要以传值方式(by value)传回一个local class object,例如像如下形式的一个算术运算:
T opeartor+(const T&, const T&){
T result;
//真正的工作在此...
return result;
}
此时提供一个copy constructor就比较合理——甚至即使default memberwise语意已经足够,它的出现会触发NRV优化。NRV优化后就不再需要调用copy constructor,因为运算结果已经被直接置于“将被传回的object”体内了。
继承体系下的对象构造
当我们定义一个object如下:
T object;
时,实际上会发生什么事情呢? 如果T有一个constructor(不论是由user提供或是由编译器合成),它会被调用。这很明显,比较不明显的是,constructor的调用真正伴随了什么?
Constructor可能内带大量的隐藏码,因为编译器会扩充每一个constructor,扩充程度视class T的继承体系而定。一般而言编译器所做的扩充操作大约如下:
- 记录在member initialization list中的data members初始化操作会被放进constructor的函数本身,并以members的声明顺序为顺序。
- 如果有一个member并没有出现在member initialization list中,但它有一个default constructor,那么该default constructor必须被调用。
- 在那之前,如果class object有virtual functions, 它们必须被设定初值,指向适当的virtual tables.
- 在那之前,所有上一层的base class constructors必须被调用,以base class生声明顺序为顺序(与member initialization list中的顺序没有关联):
- 如果base class被列于member initialization list中,那么任何明确指定的参数都应该被传递进去。、
- 如果base class没有被列于member initialization list中,而它有default constructor(或default memberwise copy constructor),那么就调用之。
- 如果base class是多重继承下的第二或后继的base class,那么this指针必须有所调整。
- 在那之前,所有virtual base class constructors必须被调用,从左到右,从最深到最浅
- 如果class被列于member initialization list中,那么如果有任何显式指定的参数,都应该传递过去。若没有列于list之中,而class有一个default constructor,亦应该调用之
- 此外,class中的每一个virtual base class subobject的偏移位置(offset)必须在执行期可被存取
- 如果class object是最底层(most-derived)的class,其constructors可能被调用,某些用以支持这一行为的机制必须被放进来。
在这一节中,我要从“C++ 语言对classes所保证的语意”这个角度来探讨constructors扩充的必要性。我再次以Point为例,并为它增加一个copy constructor、一个copy operator、一个virtual destructor如下:
class Point{
public:
Point(float x = 0.0, float y = 0.0);
Point(const Point&); //copy constructor
Point& operator=(const Point&); //copy assignment operator
virtual ~Point(); //virtual destructor
virtual float z() { return 0.0; }
protected:
float _x, _y;
};
Line class的声明和扩充结果如下,它由_begin和 _end两个点构成:
class Line{
Point _begin, _end;
public:
Line(float = 0.0, float = 0.0, float = 0.0, float = 0.0);
Line(const Point&, const Point&);
draw();
//...
};
每一个explicit constructor都会被扩充以调用其两个member class objects的constructors。如果我们定义constructor如下:
Line::Line(const Point& begin, const Point& end)
: _end(end), _begin(begin) {}
它会被编译器扩充并转换为:
Line* Line::Line(Line *this, const Point& begin, const Point& end){
this->_begin.Point::Point(begin);
this->_end.Point::Point(end);
return this;
}
由于Point声明了一个copy constructor、一个copy operator,以及一个destructor(本例为virtual),所以Line class的implicit copy constructor、copy operator和destructor都将有实际功能。(nontrival)
当程序员写下:
Line a;
时,implicit Line destructor会被合成出来(如果Line派生自Point,那么合成出来的destructor将会是virtual。然而由于Line只是内带Point objects而非继承自Point,所以被合成出来的destructor只是nontrivial而已)。在其中,它的member class objects的destructor会被调用(以其构造的相反顺序):
inline Line::~Line(Line *this){
this->_end.Point::~Point();
this->_begin.Point::~Point();
}
当然,如果Point destructor是inline函数,那么每一个调用操作会在调用地点被扩展出来。请注意,虽然Point destructor是virtual,但其调用操作(在containing class destructor之中)会被静态地决议出来(resolved statically)。
虚拟继承(Virtual Inheritance)
考虑下面这个虚拟继承:
class Point3d : public virtual Point{
public:
Point3d(float x = 0.0, float y = 0.0, float z = 0.0)
: Point(x, y), _z(z) { }
Point3d(const Point3d &rhs)
: Point(rhs), _z(rhs._z){ }
~Point3d();
Point3d& operator=(const Point3d&);
virtual float z() { return _z; }
protected:
float _z;
};
传统的“constructor扩充现象”并没有用,这是因为virtual base class的“共享性”之故:
//不合法的constructor扩充内容
Point3d* Point3d::Point3d(Point3d *this, float x, float y, float z)
{
this->Point::Point(x, y);
this->_vptr_Point3d = _vtbl_Point3d;
this->_vptr_Point3d_Point = _vtbl_Point3d_Point;
this->_z = rhs._z;
return this;
}
试想下面三种类派生情况:
class Vertex : virtual public Point{ ... }
class Vertex3d : public Point3d, public Vertex{ ... }
class PVertex : public Vertex3d { ... }
Vertex的constructor必须调用Point的constructor。然而当Point3d和Vertex同为Vertetx3d的subobjects时,它们对Point constructor的调用操作一定不可以发生,取而代之的是,作为一个最底层的class,Vertex3d有责任将Point初始化,而更往后(往下)继承,则由PVertex(不再是Vertex3d)来负责完成“被共享之Point subobject”的构造。
constructor的函数本身因而必须条件式地测试传进来的参数,然后决定调用或不调用相关的virtual base class constructors,下面就是Point3d的constructor扩充内容:
//在virtual base class情况下的constructor扩充内容
Point3d* Point3d::Point3d(Point3d* this, bool _most_derived,
float x, float y, float z){
if(_most_derived != false)
this->Point::Point(x, y);
this->_vptr_Point3d = _vtbl_Point3d;
this->vptr_Point3d_Point = _vpbl_Point3d_Point;
this->_z = rhs._z;
return this;
}
在更深层次的继承情况下,例如Vertex3d,当调用Point3d和Vertex的constructor时,总是会把_most_derived参数设为flase。于是就压制了两个constructors中对Point constructor的调用操作:
//在virtual base class情况下constructor扩充内容
Vertex3d* Vertex3d::Vertex3d(Vertex3d *this, bool _most_derived,
float x, float y, float z){
if(_most_derived != false)
this->Point::Point(x, y);
//调用上一层base classes
//设定_most_derived为false
this->Point3d::Point3d(false, x, y, z);
this->Vertex::Vertex(false, x, y);
//设定vptrs
//安插user code
return this;
}
这样的策略得以保证语意的正确无误。如:当我们定义
Point3d origin;
时,Point3d constructor可以正确调用其Point virtual base class subobject。而当我们定义:
Vertex3d cv;
时,Vertex3d constructor正确调用Point constructor。Point3d和Vertex的constructors会做每一件该做的事情——对Point的调用操作除外。
“virtual base class constructors的被调用”有着明确的定义:只有当一个完整的class object被定义出来时,它才会被调用;如果object只是某个完整object的subject,它就不会被调用
vptr初始化语意学(The Semantics of the vptr Initialization)
当我们定义一个PVertex object时,constructors的调用顺序是:
Point(x, y);
Point(x, y, z);
Vertex(x, y, z);
Vertex3d(x, y, z);
PVertex(x, y, z);
假设这个继承体系中的每一个class都定义了一个virtual function size(),该函数赋值传回class的大小。我们写:
PVertex pv;
Point3d p3d;
Point *pt = &pv;
那么这个调用操作:
pt->size();
将传回PVertex的大小,而:
pt = &p3d;
pt->size();
将传回Point3d的大小。
C++ 语言规则告诉我们,在Point3d constructor中调用的size()函数,必须被决议为Point3d::size()而不是PVertex::size()。更一般地,在一个class(本例为Point3d)的constructor(和destructor)中,经由构造中的对象(本例为PVertex)来调用一个virtual function,其函数实例应该是在此class(本例为Point3d)中有作用的那个。由于各个constructors的调用顺序,上述情况是必要的。
Constructors的调用顺序是:由根源而末端(bottom up)、由内而外(inside out)。当base class constructor执行时,derived实例还没有被构造起来。在PVertex constructor执行完毕之前,PVertex并不是一个完整的对象:Point3d constructor执行之后,只有Point3d subobject构造完毕。
如果调用操作限制必须在constructor(或destructor)中直接调用,那么答案十分明显:将每一个调用操作以静态方式决议之,千万不要用到虚拟机制。
vptr 初始化操作应该如何处理? vptr初始化操作在base class constructors调用操作之后,但是在程序员供应的代码或是“memeber initialization list中所列的members初始化操作”之前。
令每一个base class constructor设定其对象的vptr,使它指向相关的virtual table之后,构造中的对象就可以严格而正确地变成“构造过程所幻化出来的每一个class”的对象。也就是说,一个PVertex对象会先形成一个Point对象、一个Point3d对象、一个Vertex对象、一个Vertex3d对象,然后才成为一个PVeretex对象。在每一个base class constructors中,对象可以与constructors's class 的完整对象作比较。对于对象而言,“个体发生学”概况了“系统发生学”。constructor的执行算法通常如下:
- 在derived class constructor中,“所有virtual base classes”及“上一层base class”的constructors会被调用
- 上述完成之后,对象的vptrs被初始化,指向相关的virtual tables
- 如果有member initialization list的话,将在constructor体内扩展开来。这必须在vptr被设定之后才做,以免有一个virtual member function被调用。
- 最后,执行程序员所提供的代码
例如:已知下面这个由程序员定义的PVertex constructor:
PVertex::PVertex(float x, float y, float z)
: _next(0), Vertex3d(x, y, z), Point(x, y)
{
if(spyOn){
cerr << "Within PVertex::PVertex()"
<< "size: " << size() << endl;
}
}
它可能被扩展为:
//PVertex constructor的扩展结果
PVertex* PVertex::PVertex(PVertex *this, bool _most_derived,
float x, float y, float z){
//条件式调用virtual base constructor
if(_most_derived != false)
this->Point::Point(x, y);
//无条件地调用上一层base
this->Vertex3d::Vertex3d(x, y, z);
//将相关的vptr初始化
this->_vptr_PVertex = _vtbl_PVertex;
this->_vptr_Point_PVertex = _vtbl_Point_PVertex;
//程序员缩写代码
if(spyOn){
cerr << "Within PVertex::PVertex()"
Point3d::Point3d(),
<< "size: "
<< (*this->_vptr_PVertex[3].faddr)(this)
<< endl;
}
//传回被构造的对象
return this;
}
下面是vptr必须被设定的两种情况:
- 当一个完整的对象被构造起来时,如果我们声明一个Point对象,Point constructor必须设定其vptr。
- 当一个subobject constructor调用了一个virtual function(不管是直接调用还是间接调用时)。
如果我们声明一个PVertex对象,然后由于我们对其base class constructors的最新定义,其vptr将不再需要在每一个base class constructors中被设定。解决之道是把constructor分裂为一个完整的object实体和一个subobject实体。在subobject实体中,vptr的设定可以省略(如果可以的话)。
对象复制语意学(Object Copy Semantics)
一个class对于默认的copy assignment operator,在以下情况,不会表现出bitwise copy语意:
- 当class内含一个member object,而其class有一个copy assignment operator时
- 当一个class的base class有一个copy assignment operator时
- 当一个class声明了任何virtual functions(我们一定不要拷贝右端class object的vptr地址,因为它可能是一个derived class object)时
- 当class继承自一个virtual base class(不论base class有没有copy operator)时
C++ Standard上说copy assignment operators并不表示bitwist copy semantics是nontrival。实际上,只有nontrivial instances才会被合成出来
对于Point class定义如下:
class Point{
public:
Point(float x = 0.0, float y = 0.0);
//... 没有virtual function
protected:
float _x, _y;
};
当有如下赋值(assign)操作:
Point a, b;
a = b;
由bitwise copy完成,把Point b拷贝到Point a,其间并没有copy assignment operator被调用。从语意或效率上考虑,这都是我们所需要的,注意,我们还是可能提供一个copy constructor,为的是把name return vale(NRV)优化打开,copy constructor的出现不应该让我们也一定要提供一个copy assignment operator。
现在我要导入一个copy assignment operator,用以说明该opeartor在继承之下的行为:
inline Point& Point::operator=(const Point& p){
_x = p._x;
_y = p._y;
return *this;
}
现在派生一个Point3d class,(请注意是虚拟继承)
class Point3d : virtual public Point{
public:
Point3d(float x = 0.0, float y = 0.0, float z = 0.0);
//...
protected:
float _z;
};
如果我们没有为Point3d定义一个copy assignment opeartor,编译器就必须合成一个(因为前述的第二项和第四项理由),合成而得的东西可能看起来像这样:
//被合成的copy assignment operator
inline Point3d& Point3d::operator=(Point3d* const this, const Point3d &p){
//调用base class的函数实体
this->Point::operator=(p);
//memberwise copy the derived class members
_z = p._z;
return *this;
}
下面是个Vertex copy operator,其中Vertex也是虚拟继承自Point:
//class Vertex : virtual public Point
inline Vertex& Vertex::operator=(const Vertex& v){
this->Point::operator=(v);
_next = v._next;
return *this;
}
这部分太难了,摸了半天没摸清楚,等下次再啃吧。
析构语义学(Semantics of Destruction)
如果class没有定义destructor,那么只有在class内含的member object(抑或class自己的base class)拥有destructor的情况下,编译器才会自动合成一个出来。否则,destructor被视为不需要,也就不需被合成。例如,我们的Point,默认情况下并没有被编译器合成出一个destructor——甚至虽然它拥有一个virtual function:
class Point{
public:
Point(float x = 0.0, float y = 0.0);
Point(const Point&);
virtual float z();
private:
float _x, _y;
};
类似的道理,如果我们把两个Point对象组合成一个Line class:
class Line{
public:
Line(const Point&, const Point&);
//...
virtual draw();
//...
protected:
Point _begin, _end;
};
Line也不会拥有一个被合成出来的destructor,因为Point并没有destructor。
为了觉得class是否需要一个程序层面的destructor(或是constructor),请你想想一个class object的生命在哪里结束(或开始)?需要什么样的操作才能保证对象的完整?这是你写程序时比较需要了解的(或是你的class使用者比较需要了解的)。这也是constructor和destructor什么时候起作用的关键。举个例子,已知:
{
Point pt;
Point *p = new Point3d;
foo(&pt, p);
...
delete p;
}
我们看到,pt和p在作为foo()函数的参数之前,都必须先初始化为某些坐标值,这时候需要一个constructor,否则使用者必须明确的提供坐标值。一般而言,class的使用者没有办法检验一个local变量和heap变量以知道它们是否被初始化。把constructor想象为程序的一个额外负担是错误的,因为它们的工作有其必要性。如果没有它们,抽象化(abstraction)的使用就会有错误的倾向。
一个由程序员定义的destructor被扩展的方式类似constructors被扩展的方式,但顺序相反:
- destructor的函数本体现在被执行,也就是说vptr会在程序员的代码执行前被重设(reset)
- 如果class拥有member class objects。而后者拥有destructors,那么它们会以其声明的顺序的相反顺序被调用
- 如果object内含一个vptr,那么首先重设(reset)相关的virtual table
- 如果有任何直接的(上一层)nonvirtual base classes拥有destructors,它们会以其声明顺序的相反顺序被调用
- 如果有任何virtual base classes拥有destructor,而目前讨论的这个class是最尾端(most-derived)的class,那么它们会以其原来的构造顺序的相反顺序被调用
就像constructor一样,目前对于destructor的一种最佳实现策略就是维护两份destructor实体:
- 一个complete object实体,总是设定好vptr(s),并调用virtual base class destructors
- 一个base class subobject实体;除非在destructor函数中调用一个virtual function,否则它绝不会调用virtual base class destructors并设定vptr。
一个object的生命结束于其destructor开始执行之时。由于每一个base class constructor都轮番被调用,所以derived object实际上变成了一个完整的object。例如一个PVertex对象归还其内存空间之前,会依次变成一个Vertex3d对象、一个Vertex对象、一个Point3d对象,最后成为一个Point对象。当我们在destructor中调用member functiions时,对象的蜕变会因为vptr的重新设定(在每一个destructor中,在程序员所供应的码执行之前)而受到影响。