blocks|key|3152939|text|继承层次结构的构造函数调用顺序为：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3152940|Base()++
DerivedBaseTwo()++
Base()
DerivedBaseOne()++
Derived()|code-block|syntax|javascript|3152941|顺序确实是定义良好的，并且取决于您提到基类的派生的顺序以及在类中为成员声明成员的顺序。(请参阅下面的C%2B%2B标准中的参考。)|3152942|是否会调用Base()构造函数两次？|offset|length|style|BOLD|3152943|是的|3152944|Base()类构造函数在这里被调用了两次，因为有两个类DerivedBaseTwo()和DerivedBaseOne()派生自它，所以基类构造函数被调用一次。您的Derived类有两个不同的Base子对象，它们通过多个路径(一个通过DerivedBaseOne()，另一个通过DerivedBaseTwo())。|CODE|3152945|具有多重继承的类的层次结构是不寻常的，这会导致一个称为的问题。为了避免这个问题，C%2B%2B引入了的概念。|3152946|3152947|参考资料：|3152948|C%2B%2B03标准:+12.6.2/5，初始化库和成员|3152949|3152950|初始化应按以下顺序进行：|blockquote|3152951|3152952|-首先，并且仅对于下面描述的最多派生类的构造函数，虚拟基类应该按照它们在基类的有向无循环图的深度优先从左向右遍历时出现的顺序进行初始化，其中“从左到右”是基类名称在派生类基说明符列表中的出现顺序。|3152953|-然后，直接基类应该按照它们在base-specifier-list中出现的声明顺序进行初始化(不管mem-initializers的顺序如何)。|3152954|-然后，应该按照类定义中声明的顺序对非静态数据成员进行初始化(同样，不管mem-initializers的顺序如何)。|3152955|-最后，执行构造函数的主体。|3152956|entityMap^0|0|0|0|0|I|0|0|2|0|0|6|R|G|18|G|29|7|2N|4|38|G|3U|G|0|0|0|0|0|P|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1H|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1I|8|@$K|1J|L|1K|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1L|8|@$K|1M|L|1N|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1O|8|@$K|1P|L|1Q|M|S]|$K|1R|L|1S|M|S]|$K|1T|L|1U|M|S]|$K|1V|L|1W|M|S]|$K|1X|L|1Y|M|S]|$K|1Z|L|20|M|S]|$K|21|L|22|M|S]]|9|@]|A|$]]|$1|T|3|U|5|6|7|23|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|24|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|25|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|26|8|@$K|27|L|28|M|N]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|29|8|@]|9|@]|A|$]]|$1|11|3|12|5|13|7|2A|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|2C|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|2D|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|2E|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|2F|8|@]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|2G|8|@]|9|@]|A|$]]]|1E|$]]

The order of constructor calls for your inheritance hierarchy will be:
<pre><code>Base() 
DerivedBaseTwo() 
Base()
DerivedBaseOne() 
Derived()
</code></pre>
The order is indeed well-defined and depends on the order in which you mention the derivation for base classes and the order in which you declare members in the class for members. (See the reference from the C++ Standard below.)
Does the Base() constructor get called twice? 
YES
The <code>Base()</code> class constructor gets called here twice, because two classes <code>DerivedBaseTwo()</code> and <code>DerivedBaseOne()</code> derive from it, so the base class constructor gets called once for each of them. Your <code>Derived</code> class has two distinct <code>Base</code> subobjects through multiple paths (one through <code>DerivedBaseOne()</code> and the other though <code>DerivedBaseTwo()</code>).
The hierarchy of classes you have with multiple inheritance is unusual and it leads to a problem called the <a href="http://en.wikipedia.org/wiki/Diamond_problem" rel="noreferrer">Diamond Shaped Inheritance Problem</a>. To avoid this problem C++ introduces the concept of <a href="http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=/com.ibm.xlcpp8a.doc/language/ref/cplr135.htm" rel="noreferrer">Virtual base class</a>.
<hr />
Reference:
C++03 Standard: 12.6.2/5, Initializing bases and members
<blockquote>
Initialization shall proceed in the following order:
— First, and only for the constructor of the most derived class as described below, virtual base classes shall be initialized in the order they appear on a depth-first left-to-right traversal of the directed acyclic graph of base classes, where “left-to-right” is the order of appearance of the base class names in the derived class base-specifier-list.
— Then, direct base classes shall be initialized in declaration order as they appear in the base-specifier-list (regardless of the order of the mem-initializers).
— Then, nonstatic data members shall be initialized in the order they were declared in the class definition (again regardless of the order of the mem-initializers).
— Finally, the body of the constructor is executed.
</blockquote>

blocks|key|256727|text|答案是：http://www.parashift.com/c%2B%2B-faq-lite/multiple-inheritance.html#faq-25.14|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|256728|256729|要执行的第一个构造函数是层次结构中任何位置的虚拟基类。它们按照它们在基类图形的深度优先从左向右遍历中出现的顺序执行，其中从左到右是指基类名称的出现顺序。|blockquote|256730|256731|256732|因为您的多重继承声明首先列出了DerivedBaseTwo，所以它的构造顺序将在DerivedBaseOne之前执行。|style|CODE|256733|因此，在您的Derived类中，首先创建DerivedBaseTwo及其链，即：|256734|1-+Base，然后是DerivedBaseTwo|256735|然后是DerivedBaseOne和它的链：|256736|2-+Base，然后是DerivedBaseOne|256737|然后：|256738|3-+Derived是在创建其他所有内容之后创建的。|256739|此外，对于多重继承，请注意Diamond+Inheritance+Problem|256740|entityMap|0|LINK|mutability|MUTABLE|url|http://www.parashift.com/c%2B%2B-faq-lite/multiple-inheritance.html#faq-25.14|1|http://en.wikipedia.org/wiki/Diamond_problem^0|4|21|0|0|0|0|0|0|F|E|14|E|0|6|7|K|E|0|3|4|B|E|0|3|E|0|3|4|B|E|0|0|3|7|0|D|R|1|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|D|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|1G|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|1I|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|1J|8|@$A|1K|B|1L|L|M]|$A|1M|B|1N|L|M]]|9|@]|C|$]]|$1|N|3|O|5|6|7|1O|8|@$A|1P|B|1Q|L|M]|$A|1R|B|1S|L|M]]|9|@]|C|$]]|$1|P|3|Q|5|6|7|1T|8|@$A|1U|B|1V|L|M]|$A|1W|B|1X|L|M]]|9|@]|C|$]]|$1|R|3|S|5|6|7|1Y|8|@$A|1Z|B|20|L|M]]|9|@]|C|$]]|$1|T|3|U|5|6|7|21|8|@$A|22|B|23|L|M]|$A|24|B|25|L|M]]|9|@]|C|$]]|$1|V|3|W|5|6|7|26|8|@]|9|@]|C|$]]|$1|X|3|Y|5|6|7|27|8|@$A|28|B|29|L|M]]|9|@]|C|$]]|$1|Z|3|10|5|6|7|2A|8|@]|9|@$A|2B|B|2C|1|2D]]|C|$]]|$1|11|3|-4|5|6|7|2E|8|@]|9|@]|C|$]]]|12|$13|$5|14|15|16|C|$17|18]]|19|$5|14|15|16|C|$17|1A]]]]

This is answered in: <a href="http://www.parashift.com/c++-faq-lite/multiple-inheritance.html#faq-25.14" rel="nofollow">http://www.parashift.com/c++-faq-lite/multiple-inheritance.html#faq-25.14</a>

<blockquote>
 The very first constructors to be executed are the virtual base classes anywhere in the hierarchy. They are executed in the order they appear in a depth-first left-to-right traversal of the graph of base classes, where left to right refer to the order of appearance of base class names.
</blockquote>

Since your multiple inheritance declaration lists <code>DerivedBaseTwo</code> first, its construction order will be executed before <code>DerivedBaseOne</code>'s.

So in your <code>Derived</code> class, <code>DerivedBaseTwo</code> and its chain is created first, that is:

1 - <code>Base</code> then <code>DerivedBaseTwo</code>

And then <code>DerivedBaseOne</code> and its chain:

2 - <code>Base</code> then <code>DerivedBaseOne</code>

And then:

3 - <code>Derived</code> is created after everything else.

Also, with multiple inheritance be mindful of the <a href="http://en.wikipedia.org/wiki/Diamond_problem" rel="nofollow">Diamond Inheritance Problem</a>

blocks|key|3153163|text|按照您编写的方式，Derived有两个不同于的Base类型的子对象，每个子对象都从各自的DerivedBaseXXX构造函数中调用它们自己的构造函数，它是DerivedBaseXXX的子对象。调用的顺序遵循声明的顺序。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3153164|相反，如果声明DerivedBaseXXX+:+virtual+public+Base，那么只有一个+Base子对象，并且它的构造函数是从派生最多的对象中调用的，即从Derived对象中调用。|3153165|这是递归应用的，对于多重继承，您只需按照声明继承的顺序调用基类的所有构造函数来替换(1)。只有虚拟继承才会在这里增加一层真正的额外复杂性。)|3153166|entityMap^0|9|7|N|4|18|E|25|E|0|7|10|1F|4|2B|7|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|11|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|K|$]]

The way you write it, <code>Derived</code> has two distinct subobjects of type <code>Base</code>, and each gets their own constructor called from the respective <code>DerivedBaseXXX</code> constructor of which it is the subobject. The order of calls follows the order of declaration.

By contrast, of you declare <code>DerivedBaseXXX : virtual public Base</code>, then there is only one <code>Base</code> subobject, and its constructor is called from the most derived object, i.e. from the <code>Derived</code> object.

(To explain in a bit more detail: A (possibly singly-inheriting) class is constructed by first 1) calling the base class's constructor, then 2) calling the constructors of all member objects in their order of declaration, and finally 3) executing the constructor function body. This applies recursively, and for multiple inheritance, you just replace (1) by calling all the base class's constructors in the order in which the inheritance was declared. Only virtual inheritance adds a genuine extra layer of complication here.)

Are multiple-inherited constructors called multiple times? And in what order are constructors called? Does this depend on the order in the inheritance list?

Here is an example (it's only for making the situation clear, no real-life example).

<pre><code>class Base {};
class DerivedBaseOne : public Base {};
class DerivedBaseTwo : public Base {};
class Derived : public DerivedBaseTwo, public DerivedBaseOne 
{};

//somewhere in the code, is Base() called two times here?
Derived * foo = new Derived();
</code></pre>

Is the <code>Base()</code> constructor called twice? And in what order are the constructors called? Base first? Or <code>DerivedBaseOne()</code> or <code>DerivedBaseTwo()</code> first?

Are multiple-inherited constructors called multiple times?

多重继承的构造函数会被多次调用吗？构造函数是按什么顺序调用的？这取决于继承列表中的顺序吗？这里有一个例子(这只是为了让情况变得清晰，没有实际的例子)。class Base {};class DerivedBaseOne : public Base {};class DerivedBaseTwo : public Bas...

问多重继承的构造函数会被多次调用吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问多重继承的构造函数会被多次调用吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问多重继承的构造函数会被多次调用吗？
EN