C/C++编程：继承体系下的对象构造

小鱼儿 2023-01-19 04:54 17阅读 0赞

# 为继承做准备 #

对于下面声明，将为继承性质以及某些操作的动态决议做准备：

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

**虚函数的引用将初始每一个Point object拥有一个虚函数表。**

*  优点：提供了virtual接口的弹性
 *  缺点：
    
     *  每一个**对象**需要一个额外的word空间
     *  引发编译器对Point class 产生代码膨胀

我们来看看虚函数是怎么引发**类**的代码膨胀膨胀的。

*  我们所定义的**构造函数被附加了一些码，以便将vptr初始化**。这些码必须被附加在任何**基类构造函数**的调用之后，但必须在任何由程序员提供的码之前。比如：

// 代码膨胀
    Point* Point::Point(Point *this, float x, float y)
    	: _x(x), _y(y){
        
    	//设定object的virtual table pointer(vptr)
    	this->__vptr_Point = __vptr_Point ;
    
    	// 扩展member initialization list
    	this->_x = x;
    	this->_y = y;
    
    	//传回this对象
    	return this;
    }

*  **合成一个拷贝构造函数和一个copy assignment operator，而且其操作不再是trivial**(但是implicit destructor仍然是trivial)。

>  *  如果一个Point object被初始化或者以一个**派生类对象**复制，那么以位为基础(bitwise)的操作可能给vptr带来非法设定。

// 拷贝构造函数的内部合成
    inline Point* Point::Point(Point *this, const Point &rhs){
        
    	//设定object的virtual table pointer(vptr)
    	this->__vptr_Point = __vptr_Point ;
    	
    	// 将rhs坐标中的连续位拷贝到this对象，
    	// 或者是经由member assignmnt提供给一个member
    	
    	//传回this对象
    	return this;
    }

>  *  **编译器在优化状态下可能会把object的连续内容拷贝到另一个object上，而不会实现一个精确的`以成员为基础(memberwise)`的赋值操作、C++标准要求编译器尽量延迟nontrivial members的实际合成操作，直到真正遇到其使用场合为止**
> 
> --------------------
> 
> ## ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70] ##
> 
> 上面，L1的global初始化操作，L6的heap初始化操作以及L9的heap删除操作，都和以前的Point版本相同。但是对于L7的memberwise赋值操作：
> 
>     *heap = local
> 
> 很可能除非`copy assignment operator`的合成，以及其调用操作的一个`inline expansion`(内联扩展)：以this取代heap，以rhs取代local。
> 
> --------------------
> 
> 最剧烈的改变发送在以传值方式传回local的那一行。由于拷贝构造函数的出现，foobar()可能会转换成：
> 
>     Point foobar(Point &__result){
>          
>     	Point local';
>     	local.Point::Point(0.0, 0.0);
>         // ...
>     
>         // 调用拷贝构造函数
>     	 __result.Point::Point(local); 
>     	 
>     	 // local对象的析构函数将在这里调用
>     	 local.Point::~Point();
>      	return;
>     }
> 
> 如果支持named return value(NRV)优化，这个函数将会被进一步转换为：
> 
>     Point foobar(Point &__result){
>          
>     	__result.Point::Point(0.0, 0.0);
>     	 return;
>     }

总得来说，如果你的设计中**有很多函数都需要以传值方式传回一个local class oject，那么就应该提供一个copy constructor**\---- 即使default memberwise语义已经足够。它的出现会出发NPV优化，NPV优化后将不再需要调用copy constructor，因为运算结果已经被直接置于`将被传回的object`体内了

# 调用构造函数时发生了什么？ #

当我们定义一个对象：

T object

时，实际上会发生什么事情呢？如果T有一个**构造函数**(不管是用户提供的还是编译器合成的)，它会被调用。那么调用构造函数时做了写什么呢？

**构造函数可能内带大量的隐藏码，因为编译器会扩充每一个constructor，扩充程度视类T的继承体系而定**。一般编译器所做的扩充操作如下：

*  **记录在成员初始化列表中的`data members`初始化操作会被放进构造函数的函数本身，并以`members`的声明顺序为顺序**
 *  **如果有一个`member`并没有出现在成员初始化列表之中，但它有一个`默认构造函数`，那么该默认构造函数必须被调用**
 *  **在那之前，如果类对象有`vptr`，它们必须被设定初值，指向适当的虚函数表**
 *  **在那之前，所有上一层的`base class constructors`必须被调用，以基类的声明顺序为顺序**(与成员初始化列表中的顺序没有关联)
    
     *  **如果基类被列于成员初始化列表中，那么任何明确指定的参数都应该传递过去**
     *  **如果基类没有列于成员初始化列表中，而它有默认构造函数(或者default memberwise copy constructor)，那么就调用它**
     *  **如果基类是多重继承下的第二或后继的基类，那么this指针必须调整**
 *  **在那一种，所有的`virtual base class constructors`必须被调用，从左到右，从最深到最浅**
    
     *  **如果类列于成员初始化列表中，那么任何明确指定的参数都应该传递过去**
     *  **如果类没有列于成员初始化列表中，而它有默认构造函数，那么就调用它**
     *  **如果类中的每一个`virtual base class subobject`的偏移量必须在执行期可被存取**
     *  如果类对象是最底层(most-derived)的类，其构造函数可能被调用，某些用以支持这个行为的机制必须被放进来

看个例子：

对于Line，每一个explicit constructor都会被扩充以调用其两个成员类对象的constrors，如果我们定义constructor如下：

Line::Line(const Point&begin, const Point&end)
    	: _begin(begin), _end(end) {
        }

它会被编译器扩充并转换为：

Line* Line::Line(Line* this, const Point&begin, const Point&end){
        
    	this->_beigin.Point::Point(begin);
    	this->_end.Point::Point(end);
    	return this;
    }

**由于Point声明了一个 copy constructor、一个copy operator，以及一个destructor (virtual)，所以此时的implicit copy constructor、copy operator、destructor都将有实际功能(nontrival)**

当定义一个类对象：

Line a;

时， implicit line destructor会被合成出来。

*  如果Line派生自Point，那么合成出来的destructor将会是vritual
 *  但是这里Line只是内带Point object，所以被合成出来的destructors只是nontrivila而已

在其中，它的member class object的destructor会被调用(尤其构造的相反顺序)：

// 合成出来的（implicit） line destructor
    inline void Line::~Line(Line *this){
        
    	this->_end.Point::~Point();
    	this->_begin.Point:~Point();
    }

当然，如果Point destructor是inline函数，那么每一个调用操作会在调用地点被扩展开来。注意，虽然Point destructor是virtual ，但其调用操作(在Line析构函数中)会被静态的决议出来。

同样的，当：

Line b = a;

时，implicit Line copy constructor会被合成出来，成为一个inline public member、

当：

a = b;

时，implicit copy assignment operator会被合成出来，成为一个inline public member。

# 虚拟继承 #

class Point{
        
    public:
    	Point(float x = 0.0, float y = 0.0) 
    		: _x(x), _y(y){
        }
    	Point(const Point&);
    	Point& operator=(const Point&);
    
    	virtual ~Point();
    	virtual float z() {
        return 0.0;};
    protected:
    	float _x, _y;
    };
    
    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;
    };
    
    class Vertex : virtual public Point{
        };
    class Vertex3d : public Point3d, public Vertex{
        };
    class PVertex : public Vertex3d {
        };

![在这里插入图片描述][2021050811162194.png]  
当Point3d和Vertex同位Vertex3d的subobject时它们对Point构造函数的调用一定不可以发生，取而代之的是，作为一个最底层的类，Vertext3d有责任将Point初始化。而更后面的继承，则有PVertex来负责完成**被共享的Point subobject**的构造。

因此，Point3d的构造函数的扩充内容：

// 在虚基类情况下的构造函数的扩充内容
    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 = __vptr_Point3d_Point ;
    	this->_z = z;
    	return this;
    }

在更深层的继承情况下，比如Vertex3d，当调用Point3d和Vertex的constructor时，总会吧\_\_most\_derived参数设为false，于是就压制了两个constructors中对Point constructor的调用操作：

// 在虚基类情况下的构造函数的扩充内容
    Vertex3d * Vertex3d::Vertex3d (Vertex3d  *this, bool __most_derived, float x, float y, float z){
        
    	if(__most_derived != false){
        
    		this->Point::Point(x, y);
    	}
    
        //调用上一层的基类
        // 设定__most_derived = false;
    	this->Point3d::Point3d(false, x, y, z);
    	this->Vertex::Vertex(flase, x, y);
    
        // 设定vptrs
        // 安插用户代码
    
    	return this;
    }

举个例子，当我们定义：

Point3d origin;

时，Point3d可以正确调用其`Point virtual base class subobject`。

当：

Vertex3d  cv;

时，Vertex3d 构造函数会正确的调用`Point virtual base class subobject`。Point3d和Vertex的构造函数会做每一个该做的事情—对Point的调用除外

综上：**`virtual base class constructor`的调用有明确的定义：只有当一个完整的类对象被定义出来是，就被调用。如果object只是某个完整object的subobject，他就不会被调用**

因此，某些编译器会把每一个constructor一分为二，一个针对完整的object，另一个针对subobject。完整object版无条件调用virtual base constructor，设置所有的vptr等。subobject版不调用virtual base constructor，也可能不设置vptrs

# vptr初始化 #

当我们定义一个PVertex对象时，构造函数的调用顺序是：

Point (x, y);
    Point3d(x, y, z);
    Vertex(x, y, z);
    Vertex3d(x, y, z);
    PVertex(x, y, z);

假如这个继承体系中给每一个类都定义了`virtual function size()`，该函数负责传回类的大小，那么：

PVertex pv;
    Point3d p3d;
    
    Point *pt = &pv;
    pt->size();              //将传回PVertex 的大小
    
    pt = &p3d;
    pt->size();              //将传回Point3d 的大小

假如这个继承体系中每一个构造函数内带一个调用操作，像这样：

Point3d::Point3d(float x, float y, float z)
    	: _x(x), _y(y), _z(z){
        
    	if(spyOn)
    		std::cerr << "Within Point3d::Point3d() size:" <<　size() <<　"\n";
    }

当我们定义PVertex对象时，前述的五个构造函数将会怎样？每一次size()调用都会被决议为PVertex::size()吗？或者每次调用会被决议为"当前正在指向的构造函数所对应的类"的size()函数实体？

*  C++语言规则告诉我们，在Point3d构造函数中调用的size()函数，必须被决议为Point3d::size()而部署PVertex::size()
 *  更一般的，在一个类(本例为Point3d)的构造函数(和析构函数)中，经由构造中的对象(本例为PVertex)来调用一个虚函数，其函数实体应该是在此类(本例为Point3d)中有作用的那个

由于各个构造函数的调用顺序的原因，上面情况是必要的

*  **构造函数的调用顺序：从根源到末端，从内到外**
 *  **当base class constructor执行时，derived实体还没有被构造出来**。
 *  在PVertex constructor指向完毕之前，PVertex并不是一个完整的对象
 *  在Point3d constructor指向之后，自有Point3d subobject构造完毕

这就意味着，当每一个PVertex base class constructor被调用时，编译系统必须保证有适当的size()函数实体被调用。怎样才能做到这一点呢？

*  **如果调用操作限制必须在constructor(或者destructor)中直接调用**，那么答案十分明显：**将每一个调用操作以静态方式决议，千万不要用到虚拟机制**。也就是说，如果是在Point3d constructor中，就明确调用Pont3d::size()

如果size()中又调用一个虚函数，会发生什么事情呢？

*  这种情况下，这个调用也必须决议为Point3d的函数实体。
 *  而在其他情况下，这个调用是纯正的virtual，必须由虚拟机制来决定其归向。也就是说，虚拟机制本身必须知道这个调用源自于一个constructor中。

另一个可以采取的方法是：在构造函数或者析构函数内设置一个flag(必须以静态方式来决议)，然后我们就可以根据flag作为判断依据，产生条件式的调用

上面解决方法可能比较麻烦，最根本的解决方法是：**在执行一个constructor时，必须限制一组虚函数候选名单**

那怎么决定一个类的虚函数名单呢？

*  答案是根据**虚函数表**。那怎么处理虚函数表呢？答案是通过`vptr`
 *  所以，为了控制一个类中有作用的函数，编译系统只要简单的控制住vptr的初始化和设定操作即可。
 *  当然，设置vptr是编译器的责任，程序员不需要管

那么**vptr初始化操作应该如何处理**？**本质上，这需要看vptr在构造函数中的`应该在何时被初始化`而定**

那**vptr应该在何时被初始化呢**？**在基类构造函数调用操作之后，在程序员提供的码或者`成员初始化列表`中所列的成员初始化操作之前**

*  这解决了**在类中限制一组虚函数名单**的问题：
 *  如果每一个**构造函数**都一直等待这其**基类构造函数**执行完毕之后才设定其对象的`vptr`，那么每次它都能够调用正确的**虚函数实体**。

每一个**基类构造函数**设定其对象的vptr使它指向相关的虚函数表之后，构造中的对象就可以正确的编程"构造过程中所幻化出来的每一个类"的对象。也就是说，一个PVertex对象会先形成一个Point对象、一个Poin3d对象，一个Verte对象，一个Vertex3d对象，然后才成为一个PVertex对象。在每一个基类构造函数中，对象可以和构造类的完整对象做比较。构造函数的执行算法如下：

*  在**派生类构造函数**中，**所有虚基类**以及**上一层基类**的**构造函数**会被调用
 *  上述完成之后，对象的`vptr(s)`被初始化，指向相关的`virtual table(s)`
 *  如果有成员初始化列表的话，将在**构造函数**体内扩展开来。这必须在vptr被设定之后才进行，以免有虚函数被调用
 *  最后，指向程序员所提供的码

看个例子：

PVertex::PVertex(float x, float y, float z)
    	:_ next(0), Vertex3d(x, y, z), Point(x, y){
        
    	if(spyOn)
    		std::cerr << "Within PVertex::PVertex() size:" <<　size() <<　"\n";	
    }

它可能被扩展为：

// PVertex构造函数的扩展码
    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 = __vptr_Point_PVertex ;
    
    	// 程序员所写的码
    	if(spyon)
    		std::cerr << "Within PVertex::PVertex() size:"
    		          <<　(*this->__vptr_Point_PVertex[3].faddr)(this)
    		          <<　"\n";
    
    	// 传回被调用的对象
    	return this;
    }

这就解决了有关限制虚拟机制的问题。但真的解决了吗？假设Point构造函数定义为：

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

Point3d构造函数定位为：

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

怎么办？

下面是vptr必须被设定的两种情况：

*  当一个完整的对象被构造起来时。如果我们声明一个Point对象，Point构造函数必须设定其vptr
 *  当一个subobject constructor调用了一个**虚函数**(不管是直接调用还是间接调用)时

如果我们声明一个PVertex对象，然后由于我们对其base class constructor的最新定义，其vptr将不再需要在每一个base class constructor中被设定。解决方法是把constructor分裂成一个完整的object实体和一个subobject实体。在subobject实体中，vptr的设定可以省略(如果可能的话)

问题：在类的构造函数的成员初始化列表中调用该类的一个虚函数，安全么？

*  实际上是安全的。因为，vptr保证能够在成员初始化列表被扩展之前，由编译器正确设定好
 *  语意上肯能是不安全的，因为函数本身可能还需要依赖未被设定初值的成员，所以不推荐在成员初始化列表中使用虚函数

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20221021/3431bdd70baf4d21bfffbea95c142190.png
[2021050811162194.png]: /images/20221021/c0147cf106034d7389677a6b49a56dd6.png