c++对象模型 拷贝、构造、虚构

抽象基类

​ 现有如下代码:

创新互联是一家专注于成都网站设计、网站制作与策划设计,东源网站建设哪家好?创新互联做网站,专注于网站建设10余年,网设计领域的专业建站公司;建站业务涵盖:东源等地区。东源做网站价格咨询:18982081108

class Abstract_base
{
public:
    virtual ~Abstract_base() = 0;
    virtual void interface() const = 0;
    virtual const char* mumble() const { return _mumble; }
    
protected:
    char* _mumble;
}

​ 以上抽象基类声明有几个问题:

  1. 即使class被声明为抽象基类,其依然需要explicit constructor来初始化protected data member _mumble,否则derived class无法决定_mumble初值
  2. 抽象基类的virtual destructor不要声明为pure。因为每个derived class destructor会被编译器扩张,以静态方式调用每个virtual base class和上一层base class的destructor
  3. mumble()不应声明为virtual function,因为其定义的内容和类型无关,derived class并不会改写此函数
//合理的声明
class Abstract_base
{
public:
    virtual ~Abstract_base();
    virtual void interface() = 0;
    const char* mumble() const { return _mumble; }
    
protected:
    Abstract_base( char* pc = 0 );
    char* _mumble;
}
  • 一般而言,class的data member应被初始化,且只在constructor中或在class的其他member function中指定初值。其他操作都会破坏封装性质,让class的维护和修改变得愈加困难
  • 我们可以静态地定义和调用一个pure virtual function,但不能经由虚拟机制
  • c++保证继承体系中每个class object的destructors都能被调用,编译期不可压抑这一操作,且编译器并没有足够知识合成pure virtual destructor函数定义
  • 虚拟基类中,不要把所有的member functions都声明为virtual function,再靠编译器的优化把非必要的虚拟调用去除
  • 虚拟基类中,virtual function不使用const

对象构造

不继承

​ 现有如下片段:

typedef struct
{
    float x, y, z;
}Point;

Point global;

Point foobar()
{
    Point local;
    Point* heap = new Point;
    *heap = local;
    delete heap;
    return local;
}
  • 对于Point这样的声明,在c++会被贴上Plain OI' Data标签。编译器并不会为其声明default constrcutor、destructor、copy constructor、copy assignment operator

  • 对于 Point global; 这样的定义,在c++中members并没有被定义或调用,行为和c如出一辙。编译器并不会调用constructor和destructor。除非在c中,global被视作临时性定义

    临时性定义:因为没有显示初始化操作,一个临时性定义可以在程序多次发生,但编译器最终会将这些实例链接折叠起来,只留下一个实例,放在data segment中"保留给未初始化的global object使用的"空间
    
    但在c++中并不支持临时性定义,对于此例,会阻止后续的定义
    
  • c++中所有全局对象都被以初始化过的数据对待

  • 对于 Point* heap = new Point;编译器并不会调用default constructor,只是 Point* heap = __new( sizeof(Point) )。delete亦是如此

  • 对于*heap = local;编译器并不会调用copy assignment operator做拷贝,但只是像c那样做简单的bitwise

  • return操作也是,只是简单的bitwise,并没有调用copy constructor

​ 现有如下片段:

class Point
{
    public:
    	Point( float x = 0.0, float y = 0.0, float z = 0.0 ) : _x(x), _y(y), _z(z) { }
    	//没有copy constructor,copy operator,destructor
    
    private:
    	float _x, _y, _z;
}

void do()
{
    Point local1 = {1.0, 1.0, 1.0};
}
  • 对于将class中成员设定常量值,使用explicit initialization list更有效率。因为当函数的活动记录(activation record)被放进堆栈,initialization list的常量即可放入local1内存中

    活动记录过程的调用是过程的一次活动,当过程语句(及其调用)结束后,活动生命周期结束。变量的生命周期为其从被定义后有效存在的时间
    
  • 但explicit initialization list也有不足:

    • class member需要为public
    • 只能指定常量,因为其常量在编译器即可求值
    • 编译器并没有自动施行它,初始化很可能失败
  • 若调用之前的例子,放在现在编译器也不会调用destructor,因为并没有显示地提供destructor

    delete heap;
    

​ 现有如下片段:

class Point
{
    public:
    	Point( float x = 0.0, float y = 0.0, float z = 0.0 ) : _x(x), _y(y), _z(z) { }
    	virtual float z();
    	//没有copy constructor,copy operator,destructor
    
    private:
    	float _x, _y;
}
  • 导入了virtual functions会引发编译器对class Point的膨胀:

    • 定义的constructor附加一些代码,以便将vptr初始化。这些代码附加在任何base class constructors调用后,user code之前
    • 合成一个copy constructor 和 一个assignment operator,且不再是有用的(trivial),但implicit desctructor仍为有用的
  • 这种情况下,编译器在优化状态下可能会把object的连续内容拷贝到另一个object上,且不是memberwise。因此,编译器会尽量延迟nontrivial members的合成操作,直到遇到合适场合

  • 例如之前的例子,此时就很有可能合成copy assignment operator,以及inline expansion。对于return,又因为合成copy constructor,函数内部又需改写;但若编译器支持NRV,内部会改写为constructor,此时将不用调用copy constructor

    *heap = local;
    
    return local;
    

继承

T object;

对于以上定义,编译器会扩充每一个constructor。一般而言扩充如下:

  • 所有virtual base class constructors必须被调用,从左到右,从最深到最浅
    • 若class被列于member initialization list,如果有任何显示指定的参数,都应传过去。若没有列于list,而class有default constructor,则调用此
    • 此外,class中的每个virtual base class subobject的offset必须在执行期可被存取
    • 若 class object 是最底层的class,其constructors可能被调用
  • 所有上层的base class constructors必须被调用,以base class的声明顺序
    • 若class被列于member initialization list,如果有任何显示指定的参数,都应传过去。若没有列于list,而class有default constructor,则调用此
    • 若base class是多重继承下的第二或后继base class,那么this指针需调整
  • 若class object有virtual table pointers,其需指定初值
  • 记录在member initialization list的data member初始化会被放进constructor函数本体,以members声明顺序为顺序。若有一个member没有出现在member initialization list,但其有default constructor,那么该default constructor必须被调用

​ 实例:

class Point
{
public:
    Point( float x = 0.0, float y = 0.0 );
    Point( const Point& );
    Point& operator=( const Point& );
    
    virtual ~Point();
    virtual float z() { return 0.0; }
    
protected:
    float _x, _y;
};

class Line
{
    Point _begin, _end;
public:
    Line( float = 0.0, float = 0.0, float = 0.0, float = 0.0 );
    Line( const Point&, const Point& ) : _end(end), _begin(begin);
    
    draw();
    ...
};

//扩充
Line* Line::Line( Line* this, const Point&, const Point& )
{
    this->begin.Point::Point( begin );
    this->end.Point::Point( end );
    return this;
}

//合成隐式的Line destructor。若Line派生自Point,合成的将会是virtual
Line a;
  • 对于虚拟继承,以上constructor扩张方式将不再支持,这是因为virtual base class的共享性,否则会导致多次virtual base class的constructor。针对虚拟继承,每个derived class constructor扩张方式需发生改变,添加 bool __most_derived来判断是否为派生最底层,若为最底层则调用virtual base class consturctor

vptr初始化

​ 现有如下片段:

//假设每个class都定义了virtual function size(),传回class大小,每个constrcutor中调用size()
Point(x,y);
Point3d(x,y,z);
Vertex(x,y,z);
Vertex3d(x,y,z);
PVertex(x,y,z);

//当我们定义PVertex object,前五个constructor各自调用自己的size()
  • 做到如上机制,我们需要在执行一个constructor时,必须限制一组virtual functions候选名单。通过控制vptr的初始化和设定
  • vptr的初始化应在base class constructors调用后,在member initialization list所列member初始化操作前

​ 此时,constructor也需改变:

  • 在derived class constructor中,调用所有virtual base classes及上一层base class 的constructors
  • 然后,初始化vptr,指向相关virtual table
  • 若有member initialization list,将在constructor展开,但必须在vptr被设定后才施行
  • 最后,执行user code
//改变后的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 class
    this->Vertex3d::Vertex3d(x,y,z);
        
    //初始化vptr
    this->__vptr_PVertex = __vtbl_PVertex;
    this->__vptr_Point__PVertex = __vtbl_Point__PVertex;
    
    //size()
    ...
        
    return this;
}

​ 当然以上方案并不完美:

Point::Point( float x, float y ) : _x(x), _y(y) { }
Point3d::Point3d( float x, float y, float z ) : Point(x,y), _z(z) { }

​ 此时,若声明PVertex,由于对其base class constructor的最新定义,其vptr将不再需要在每个base class constructor中被设定。因此,我们需要把constructor分裂为一个完整的object实例和sunobject实例

  • 在class的constructor的member initialization list中调用该class 的virtual functions,在语意上可能不安全,因为函数本身可能得依赖未被设立初值的members

对象复制

​ 设计一个class,并以一个class object指定给另一个class object,我们有三种选择:

  1. 什么都不做,实施默认行为
  2. 提供一个explicit copy assignment operator
  3. 显示拒绝把class object指定给另一个class object。也就是将copy assignment operator声明为private,且不提供定义
  • 只有在默认的member wise copy行为不安全或不正确时,才需要设计一个copy assignment operator。且如果class有bitwise copy,隐式的assignment operator不会合成

​ class对于default copy assignment operator,在以下情况,不会表现bitwise copy:

  1. 当class 内含member object,而其class有一个copy assignment operator
  2. 当class的base class有一个copy assignment operator
  3. 当class声明了任何virtual functions。一定别拷贝右边class object的vptr地址,它很有可能是derived class object
  4. 当class继承自virtual base class
  • copy assignment operators并不表示bitwise copy是nontrivial。只有nontrivial instances才被合成

  • 即使赋值由bitwise copy完成,并没有调用copy assignment operator,但还是需要提供一个copy constructor,以此打开NRV优化

  • 尽可能不要允许一个virtual base class的拷贝操作。不要在任何virtual base class中声明数据

对象效能

  • 对于单一继承和多重继承,若class使用bitwise copy,一般不会合成copy constructor,就不会增加效率成本

  • 对于虚拟继承,bitwise copy不再支持,而是合成copy assignment operator和inline copy constructor,导致成本大大增加。且继承体系复杂度增加,对象拷贝和构造的成本也会增加

对象析构

  • 若class没定义destructor,只有在class内含member object含有destructor时,编译器才会合成destructor
  • 若base class不含desturctor,那么derived class也不需要desturctor

​ destructor被扩展的方式。与constructor相似,但顺序相反:

  • destructor函数本体先被执行
  • 若class含有member class object,而后者含有destructors,他们会以其声明顺序的相反顺序被调用
  • 若object内含vptr,现需被重新指定,指向适当的base class的virtual table
  • 若有任何直接的nonvirtual base classes含有destructor,它们会以其相反的声明顺序被调用
  • 若由任何virtual base classes含有destructor,如之前的PVertex例子,会以其原来的构造顺序的相反顺序调用

分享文章:c++对象模型 拷贝、构造、虚构
当前地址:http://scyanting.com/article/dsoiegh.html