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;
}

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

即使class被声明为抽象基类，其依然需要explicit constructor来初始化protected data member _mumble，否则derived class无法决定_mumble初值
抽象基类的virtual destructor不要声明为pure。因为每个derived class destructor会被编译器扩张，以静态方式调用每个virtual base class和上一层base class的destructor
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，我们有三种选择：

什么都不做，实施默认行为
提供一个explicit copy assignment operator
显示拒绝把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：

当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

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://dzwzjz.com/article/dsoiegh.html

大橙子网站建设，新征程启航

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

抽象基类

对象构造

不继承

继承

vptr初始化

对象复制

对象效能

对象析构

其他资讯

大橙子网站建设，新征程启航

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

抽象基类

对象构造

不继承

继承

vptr初始化

对象复制

对象效能

对象析构

其他资讯

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