抽象基类

​ 现有如下代码：

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例子，会以其原来的构造顺序的相反顺序调用