继承体系下的对象构造

1.先内含一个类

类声明

class Point
{public :Point(int x = 0, int y = 0):X(x), Y(y){};Point(const Point& Temp);Point& operator=(const Point& Temp);virtual ~Point() {};virtual int z() { return 0; }inline int getX(void) const { return X; }inline int getY(void) const { return Y; }inline void setX(int x) { X = x; }inline void setY(int y) { Y = y; }
protected:int X, Y;
};class Line
{public:Line(int x0, int y0, int x1, int y1);Line(const Point& begin, const Point& end) : Begin(begin), End(end) {}protected:Point Begin, End;
};

某些实现


Line::Line(int x0, int y0, int x1, int y1)
{this->Begin.setX(x0);this->Begin.setY(y0);this->Begin.setX(x1);this->Begin.setY(y1);
}
Point&  Point::operator=(const Point& Temp)
{this->X = Temp.X;this->Y = Temp.Y;return *this;
}Point::Point(const Point& Temp)
{this->X = Temp.X;this->Y = Temp.Y;
}

调用

int main()
{Line a(1,2,3,4);Line b = a;return 0;
}

结果

①我们可以看到Line这个类中内含了另外一个类的对象，而且Line并未显示拥有一个=赋值运算符的重载，也没有拥有一个拷贝构造函数，但是却可以把一个Line b = a(拷贝构造函数)，c = a;(赋值运算符的重载)
所以编译器为我们隐式生成了这些函数
②当内含一个对象的时候，会先调用内含对象的构造函数，在调用自身的构造函数
③由于Point声明了一个拷贝构造函数，一个重载赋值运算符，一个虚析构函数，所以Line的隐式拷贝构造函数，隐式重载赋值运算符，和析构函数（继承是虚的，本例子中是内含是nontrivial）
可能生成的Line的析构函数

Line::~Line(Line *this)
{this->End.Point::~Point();this->Begin.Point::~Point();
}

2.构造函数调用顺序

1、先调用基类的构造函数，调用顺序与继承顺序保持一致

2、再调用派生类中的内含的对象的构造函数，调用顺序与内含对象的声明顺序保持一致，与初始化列表中的顺序无关。

3、最后调用派生类的构造函数。

而析构函数与构造函数的顺序完全相反。

3.虚拟继承（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){}Poin3d(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的“共享性”原因：

//C++伪码
//不合法constructor扩展
Point3d*
Point3d::Point3d(Point3d* this,float x = 0.0,float y = 0.0,float z = 0.0)
{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同为Vertex3d的subobject时，它们对Point constructor掉头操作一定不可以发生，应该是作为最底层的class，有责任去将Point初始化。

传统的策略情况下扩充的constructor，会导致constructor中更多的扩充内容，用以指示virtual base class constructor应不应该被调用，constructor的函数体必须因条件测试参数，决定调不调用相关的virtual base class constructors。如下是正确的Pointd3d的constructor：

//C++伪码
//在virtual base class情况下的constructor扩充
Point3d*
Point3d::Point3d(Point3d* this,float x = 0.0,float y = 0.0,float z = 0.0)
{if(_most_derived != false)this->Point::Point(x,y);this->vptr_Point3d = _vtbl_Point3d;this->_vptr_Point3d_Point = _vtbl_Point3d_Point;this->_z = rhs._z;return this;
}

在更深的继承体系下，Vertex3d，调用Point3d和Vertex的constructor时，总会把_most_derived设置为false，于是就压制了两个constructors中对Point constructor的调用：

//C++伪码
//在virtual base class情况下的constructor扩充
Vertex3d*
Vertex3d::Vertex3d(Vertex3d* this,float x = 0.0,float y = 0.0,float z = 0.0)
{if(_most_derived != false)this->Point::Point(x,y);//调用上层base classes//设定_most_derived为flasethis->Point3d::Point3d(false,x,y,z);this->Vertex::Vertex(false,x,y);//安插vptrs//安插user codereturn this;
}

这样策略下以保证语意的正确无误，当我们定义Point3d和Vertex3d cv时，都可以正确的调用Point constructor。

某些编译器支持把一个constructor一分为二，一个针对完整的object定义，另一个针对如果完整object是subobject；完整的版本，无条件调用virtual base constructor，设置所有的vptr；subobject版本则不调用virtual base constructor，也可能不设定vptr。

4.vptr初始化语意学（The Semantics of the vptr Initialization）

当我们定义一个PVertex object时，constructors调用顺序：

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

假设这个继承体系中每一个class都定义了virtual function size()，此函数返回class的大小。当我们如下操作，传回PVertex大小：

PVertex pv;
Poin3d p3d;Point* pt = & pv;
pt->size();

假设这个集成体系中每一个constructor内含一个调用操作：
就是在每一个基类的构造函数内部写下一个虚函数size()

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

那么他会产生多态调用吗？
对于如上调用而言，如果调用操作限制在constructor（或destructor）中，每一个调用都是静态的，不会是动态的。

在执行一个constructor时，必须限制一组virtual function候选名单，决定virtual function的候选名单的virtual table。virtual table是通过vptr来处理的。所以编译器为了控制一个class中所有作用的函数，编译器系统只要简单的控制vptr的初始化和操作即可。设定vptr是编译器的责任，程序员不需要操心。

vptr在constructor中的初始化时间是：在base class constructors调用操作之后，但是在程序员提供的代码或是member initialization list中所有的member初始化操作之前。

每一个constructor都一直等到起base class constructors执行完毕之后才设定其对象的vptr，那么每次它都能够正确的调用virtual function实例。

令每一个base class constructor设定其对象的vptr，使它指向相关的virtual table之后，构造中的对象就可以严格而正确的“构造过程中所幻化出来的每一个class”的对象。constructor执行通常如下：

①在derived class constructor中，“所有virtual base classes”及“上一层base class”的constructor会被调用。
②上述完成之后，对象的vptr被初始化，指向vtbl。
③如果有member initialization list的话，将在constructor体内扩展开来，这必须在vptr被设定之后才做，以免有一个virtual member function被调用。
④执行程序员所提供的代码。
构造函数的调用顺序从根到叶子从内到外也就是说只有当自己的构造函数被调用完成之后，才是真正的构造完毕

vptr必须设定的情况
1.当一个完整的对象被构造起来的时候。
②当一个subobject constructor 调用了一个virtual function时