为什么先调用基类构造函数然后派生类构造函数

Question

According to c++ rules, when defining a derived class object, the base class constructor is called to initialize the base class members and then the derived class constructor. For the destructor, the rule reverts.

I'm wondering why this rule should be obeyed. Why first base constructor and then derived class constructor? Is there any reason for doing this? or just because it's the definition of c++.

Thanks,

Answer 1

because members of the derived class may depend on members of the base class, members of the base class have to be initialized first.

You can't argue the opposite.

Answer 2

An object of class type consists of subobjects - its base class subobjects and (non-static) data members.

Before a subobject is constructed, in its place is raw uninitialized storage, which you must not use as an object.

The subobjects of an object are constructed before the body of the constructor for the object is entered, so that you can use these subobjects in the constructor body.

That base class subobjects are constructed before member subobjects is just a rule, but may be motivated by the following observations:

• A derived object is a base object and adds additional members and behaviors. It seems natural to first construct the base part on which the derived part rests, before adding the new parts.
• When the base class subobject is constructed, you can use it (except for polymorphic behavior) through it regular interfaces, including in the initialization of data members. The converse is not true: you can't access derived class members the regular way (through encapsulating member functions) until the derived object is fully constructed (which includes the base class subobjects.

A technical reason for this construction order is that compilers typically initialize the data needed for polymorphism (vtable pointers) in constructors. So first a base class constructor initializes this for its class, then the derived class constructor overwrites this data for the derived class. This also corresponds to the rules for behavior of polymorphic functions in constructors.