blocks|key|900484|text|虚函数对销毁的顺序没有影响，而虚拟基类则不同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|900485|如果没有虚拟基类，派生类总是在它们的基类之前被销毁；这与构造它们的顺序相反。|900486|对于派生最多的类，首先构造虚拟基类，然后再构造其他基类和派生最多的类本身。破坏以相反的顺序发生。这意味着，如果一个虚拟基类不是被销毁的最多的派生类，那么该虚拟基类可以在从它虚拟派生的类之后被销毁。对于直接基类，这种情况永远不会发生。|900487|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Virtual functions make no difference to the order of destruction, virtual base classes, on the other hand, do.

Without virtual base classes, derived classes are always destroyed before their base classes; this is the reverse order in which they are constructed.

For the most derived class, virtual base classes are constructed first, before other base classes and before the most derived class itself. Destruction happens in the reverse order. This means that a virtual base may be destroyed after a class that derives virtually from it, if that class is not the most derived class being destroyed. This can never happen for direct base classes.

blocks|key|1645388|text|这是与构造函数相反的方式。所以先推导出来。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1645389|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It is the opposite way as the constructors. So derived first.

blocks|key|4176272|text|自下而上的破坏顺序。(从派生到基础)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4176273|4176274|简略回答:与构造函数的顺序完全相反。|blockquote|4176275|4176276|长答案:假设“最多派生的”类是D，这意味着最初创建的实际对象是D类，并且D从B1和B2继承了multiply+(并且是非虚拟的)。与大多数派生类D对应的子对象首先运行，然后以相反的声明顺序运行其非虚拟基类的dtors。因此析构函数的顺序是D，B2，B1。此规则以递归方式应用；例如，如果B1继承自B1a和B1b，而B2继承自B2a和B2b，则最终顺序为D、B2、B2b、B2a、B1、B1b、B1a。|4176277|4176278|请参阅c%2B%2B+faq+section+25|offset|length|4176279|entityMap|0|LINK|mutability|MUTABLE|url|http://www.parashift.com/c%2B%2B-faq-lite/multiple-inheritance.html#faq-25.15^0|0|0|0|0|0|0|3|I|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|X|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|Z|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@$L|12|M|13|1|14]]|A|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]]]

Order of destructions if from the bottom up. (from derived to base)

<blockquote>
 Short answer: the exact opposite of
 the constructor order.
 
 Long answer: suppose the "most
 derived" class is D, meaning the
 actual object that was originally
 created was of class D, and that D
 inherits multiply (and non-virtually)
 from B1 and B2. The sub-object
 corresponding to most-derived class D
 runs first, followed by the dtors for
 its non-virtual base classes in
 reverse declaration-order. Thus the
 destructor order will be D, B2, B1.
 This rule is applied recursively; for
 example, if B1 inherits from B1a and
 B1b, and B2 inherits from B2a and B2b,
 the final order is D, B2, B2b, B2a,
 B1, B1b, B1a.
</blockquote>

See the <a href="http://www.parashift.com/c++-faq-lite/multiple-inheritance.html#faq-25.15" rel="nofollow noreferrer">c++ faq section 25</a>

blocks|key|1645420|text|销毁顺序是反向的构造顺序。我最近做了一个小工具来显示任何层次结构的构造顺序。看这里：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1645421|1645422|Where+is+the+"virtual"+keyword+necessary+in+a+complex+multiple+inheritance+hierarchy?|unordered-list-item|offset|length|1645423|1645424|在图中，具有较小数量的节点被构造为first和destructed+last。|style|BOLD|1645425|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3414639/where-is-the-virtual-keyword-necessary-in-a-complex-multiple-inheritance-hierar/3414910#3414910^0|0|0|0|2D|0|0|0|H|5|Y|4|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|W|8|@]|9|@$F|X|G|Y|1|Z]]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|11|8|@$F|12|G|13|K|L]|$F|14|G|15|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

The destruction order is the construction order backwards. I've recently made a small tool to display the construction order for any hierarchy. Look here:

<ul>
<li><a href="https://stackoverflow.com/questions/3414639/where-is-the-virtual-keyword-necessary-in-a-complex-multiple-inheritance-hierar/3414910#3414910">Where is the &quot;virtual&quot; keyword necessary in a complex multiple inheritance hierarchy?</a></li>
</ul>

In the diagrams, the nodes with the smaller numbers are constructed first and destructed last.

blocks|key|2768017|text|首先是派生的，然后是基础。在非虚拟情况下无差别。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2768018|补充说明。当你有继承和虚方法时，你必须将析构函数声明为虚的，否则你在删除时可能会有未定义的行为。|2768019|例如，假设Derived是从Base派生的，并且您使用以下行分配derived：|2768020|Base+*o+=+new+Derived();
delete(o);|code-block|syntax|javascript|2768021|如果这种情况发生在您的代码中，并且Base没有虚拟析构函数，则产生的行为是未定义的。通常，只会调用Base的析构函数。将不会调用派生的析构函数，因为您正在基指针上调用delete。但是，程序可能会崩溃。一旦你进入了未定义行为的领域，所有的赌注都会消失，你的运行代码注定会失败。为了防止混乱，基础析构函数必须是虚拟的。|2768022|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

First the derived, then the base. No difference wrt the non-virtual cases. 

Additional note. When you have inheritance and virtual methods, you have to declare destructors as virtual, otherwise you can have undefined behavior at deletion.

Example, suppose Derived is derived from Base, and you allocate Derived with the following line:

<pre><code>Base *o = new Derived();
delete(o);
</code></pre>

If this case occurs in your code, and Base has no virtual destructor, the resulting behavior is undefined. Typically, only the destructor of Base will be called. The destructor of Derived will not be called, because you are calling delete on a Base pointer. However, the program might crash instead. Once you are in the realm of undefined behavior, all bets are off and your running code is doomed. To prevent chaos the Base destructor must be virtual.

blocks|key|1645457|text|由于我看不到虚拟函数如何更改任何对象的销毁顺序，因此我假设您指的是虚拟继承场景中基类和数据成员的销毁顺序。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1645458|子对象是由构造的|1645459|1645460|base类是从大多数基类到大多数derived;|ordered-list-item|1645461|multiple基类构造的；按照它们声明为基类的顺序构造；遵循上述两条规则，在所有其他基类之前构造基类；按照成员的declaration.|1645462|顺序，在执行封闭对象的构造函数主体之前构造成员|1645463|销毁是与构造相反的，所以你只需要记住上面的内容。|1645464|然而，上面的四个规则是按这个顺序排列的，因为这是有意义的，如果你理解了为什么这个顺序是有意义的，你甚至不需要记住这四个规则，但可以从你的理解中推断出它们(就像我刚刚做的那样)。因此，让我们检查一下该顺序：|1645465|1645466|您可能想要使用基类从派生类的构造函数提供的任何服务。当然，在实际构造(基类)对象之前，您不能使用它。因此，在构造派生类时，需要已经构造基类。(顺便说一下，这也解释了为什么虚函数调度不能从构造函数中完全工作:当构造子对象时，只有基类的子对象已经构造；派生类的子对象还没有构造。因此，不能将对虚函数的调用调度到派生类。像往常一样，析构函数是相同的，只是向后。)|unordered-list-item|1645467|由于多个基类是相等的兄弟，所以必须任意选择一些顺序。最终，声明的顺序是最容易使用的。同样是同级的数据成员遵循相同的(或多或少是任意的)声明顺序的rule.|1645468|Virtual基类是奇怪的野兽。因为总是只有一个虚拟基类的子对象，所以有一个特殊的规则，它总是需要首先从大多数派生类的构造函数开始构造。(这就是为什么虚拟基类作为没有数据的抽象基类工作得最好，只有默认的constructors.)|1645469|1645470|entityMap^0|Z|2|0|5|3|0|0|0|O|0|0|1D|0|0|0|2|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|L|3|M|5|K|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|1H|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|R|3|S|5|6|7|1L|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]|$1|U|3|V|5|W|7|1N|8|@]|D|@]|E|$]]|$1|X|3|Y|5|W|7|1O|8|@]|D|@]|E|$]]|$1|Z|3|10|5|W|7|1P|8|@]|D|@]|E|$]]|$1|11|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|12|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]]|13|$]]

Since I don't see how virtual function change any objects' destruction order, I assume you're referring to the order of destruction for base classes and data members in a virtual inheritance scenario. 

Sub-objects are constructed 

<ol>
<li>base classes are constructed from most base to most derived;</li>
<li>multiple base classes are constructed in the order of their declaration as base classes;</li>
<li>virtual base classes are constructed before all others, amongst themselves adhering to the above two rules; </li>
<li>data members are constructed before the enclosing object's constructor's body is executed, in order of their declaration.</li>
</ol>

Destruction is simply the opposite of construction, so you only need to memorize the above. 

However, the above four rules are in that order because that makes sense, and if you understand why this order makes sense, you will not even have to memorize those four rules, but can infer them from your understanding (as I just did). So let's examine that order: 

<ul>
<li>You might want to use whatever service the base class provide from a derived class' constructor. Of course, you cannot use a (base) class object before it's actually constructed. Therefore, when a derived class is constructed, the base class needs to be already constructed. (Incidentally, this also explains why the virtual function dispatching doesn't fully work from within constructors: When a sub-object is constructed, only the sub-objects of base classes are already constructed; the derived classes' sub-objects are not yet constructed. Therefore a call to a virtual function must not be dispatched to a derived class. As always, destructors are the same, just backwards.) </li>
<li>With multiple base classes being equal siblings, some order had to be picked arbitrarily. Ultimately, the order of declaration is the most simple one to use. Data members, which also are equal siblings, follow the same (more or less arbitrary) in-order-of-declaration rule.</li>
<li>Virtual base classes are strange beasts. Because there will always only be one sub-object of a virtual base class, there's that special rule which says it always needs to be constructed first, right from the most derived class' constructor. (Which is why virtual base classes work best as abstract base classes with no data and only default constructors.) </li>
</ul>

blocks|key|2768120|text|第12.6.2/5节：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2768121|2768122|初始化应按以下顺序进行：|blockquote|2768123|2768124|2768125|首先，并且仅对于如下所述的最多派生类的构造函数，虚拟基类应该按照它们在基类的有向无循环图的深度优先从左向右遍历时出现的顺序来初始化，其中，“从左到右”是派生类中基类名称的出现顺序base-specifier-list.|2768126|Then，直接基类应该按照它们在基说明符列表中出现的声明顺序来初始化(不管mem-initializers).|unordered-list-item|2768127|
|2768128|Then，的顺序如何非静态数据成员应该按照在类定义中声明的顺序进行初始化(同样，不管mem-initializers的顺序如何)。-最后，执行构造函数的主体。|2768129|2768130|注意:声明顺序是为了确保基对象和成员子对象以与初始化相反的顺序被销毁。|2768131|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|X|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|11|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|12|8|@]|9|@]|A|$]]|$1|O|3|P|5|L|7|13|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|15|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|U|$]]

Section 12.6.2/5:
<blockquote>
Initialization shall proceed in the following order:
<ul>
<li>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.</li>
<li>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).</li>
<li>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.</li>
</ul>
[Note: the declaration order is mandated to ensure that base and
member subobjects are destroyed in the reverse order of
initialization. ]
</blockquote>

Can some one please help what the order of destruction is when I am using virtual functions. Does it start with the base class and then derived class?

order of destruction using virtual

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

谁能帮帮忙，当我使用虚拟函数时，销毁的顺序是什么？它是从基类开始，然后是派生类吗？

问使用虚拟的销毁顺序
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用虚拟的销毁顺序EN