blocks|key|3917106|text|它的发生是因为你让它发生。自动变量的析构函数总是在变量超出作用域时被调用。你也这么说过。总共打了两个电话。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3917107|调用对象的析构函数不会通知C%2B%2B不要再次调用它，因为在正常执行中不需要跟踪。|3917108|解决方案是永远不要手动调用析构函数。|3917109|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|$]]

It happens because you told it to happen. The destructor for an automatic variable is always called when the variable goes out of scope. You also called it. That's two calls total.

Calling an object's destructor does not signal to C++ not to call it again, since in normal execution there is no need to keep track.

The solution is to never manually call your destructor.

blocks|key|2149674|text|调用析构函数不会释放对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2149675|析构函数的作用是清理对象的内部结构，然后在析构函数完成后释放对象本身。|2149676|做你正在做的事情是错误的，就像你可以在一个对象上调用delete两次一样，但是这样做是错误的。|2149677|只有极少数的情况下，你想手动调用析构函数，而这不是其中之一。它确实适用于这样的情况:你在内存位置手动构造一个对象，使用there+new，然后需要能够在不释放内存的情况下销毁它。|2149678|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Calling the destructor does not free the object.

The destructor is there to clean up the internals of the object and then the object itsself is freed after the destructor finishes.

It's an error to do what you are doing similarly to the way that you can call delete twice on an object but it's an error to do so.

There are only a very few cases where you want to call the destructor manually and this isn't one of them. It's really there for the times you manually construct an object at a memory location using placement new and then need to be able to destruct it without freeing the memory.

blocks|key|3826786|text|你不应该实际调用解构函数。它是由运行时支持为您调用的。因此，您需要调用它一次，而运行时支持人员将调用第二次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3826787|下面是一些关于析构函数的内容：|3826788|http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%252Fcom.ibm.xlcpp8a.doc%252Flanguage%252Fref%252Fcplr380.htm|offset|length|3826789|您可以显式调用解构函数，但不建议这样做，通常它们是隐式调用的。|3826790|entityMap|0|LINK|mutability|MUTABLE|url|http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%252Fcom.ibm.xlcpp8a.doc%252Flanguage%252Fref%252Fcplr380.htm^0|0|0|0|3I|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$F|U|G|V|1|W]]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

You shouldn't actually call the deconstructor. It is called for you by the runtime support. Hence your calling it once and the runtime support is calling it the second time.

Here is some food for thought on destructors:

<a href="http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Fcplr380.htm" rel="nofollow">http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Fcplr380.htm</a>

You can explicitly call deconstructors, however it's not recommended, normally they are implicitly called.

blocks|key|2149697|text|您不必显式调用析构函数，它会在变量超出作用域时自动调用(这里是在return+0;语句之后)。这就是为什么它会被调用两次，你调用它，然后系统调用它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2149698|如果你想自己显式地移除这个类的实例，你需要动态分配它：|2149699|temp+*t+=+new+temp;+++++
//+do+stuff+with+t...
delete+t;++++//+do+not+forget+this,+or+the+constructor+is+not+being+called+at+all|code-block|syntax|javascript|2149700|entityMap^0|W|9|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

You don't call the destructor explicitly, it is called automatically when the variable goes out of scope (here after the <code>return 0;</code> statement). That's why it is called twice, you call it, and then the system calls it.

If you want to be able to remove an instance of this class yourself, explicitly, you need to dynamically allocate it:

<pre><code>temp *t = new temp; 
// do stuff with t...
delete t; // do not forget this, or the constructor is not being called at all
</code></pre>

blocks|key|2149702|text|析构函数是指当对象超出作用域时，如果对象在堆栈中，则调用析构函数，或者在首先使用new运算符在堆上创建对象时，使用delete显式析构对象时调用析构函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2149703|编译器或运行时系统无法跟踪析构函数是否由您手动调用。此外，调用析构函数也是一种非常糟糕的做法。|2149704|如果您想在删除对象之前执行一些手动清理(除了从内存中删除或从堆栈中删除对象之外)，您可以这样做。|2149705|在这里，您希望允许客户端手动清理东西，甚至在对象被删除之前。但除此之外，如果客户没有清理它，您可以清理它。|2149706|class+A
{
public:
++++A()+:+_closed(false)
++++{}

++++~A()
++++{
++++++++close();
++++}

++++void+close()
++++{
++++++++if+(!+_closed())+{
++++++++++++//+close+file+handles+etc.
++++++++}
++++}

private:
++++bool+_closed
}|code-block|syntax|javascript|2149707|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|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Destructor is meant to be called when an object goes out of scope if the object is in the stack as in this case or called when it is explicitly destructed with delete when the object is created on the heap with new operator at the first place.

There is no way for the compiler or the run time system to keep track whether the destructor is called by you manually or not. Also it is a very bad practice to make a call to the destructor. 

If you want to do some manual cleaning (other than the object being deleted from memory or getting removed from the stack) before the object getting deleted you may do something like this.

Here you want to allow the client to manually clean things, even before the object gets deleted. But in addition to that, you clean things if client misses to clean it.

<pre><code>class A
{
public:
 A() : _closed(false)
 {}

 ~A()
 {
 close();
 }

 void close()
 {
 if (! _closed()) {
 // close file handles etc.
 }
 }

private:
 bool _closed
}
</code></pre>

blocks|key|3826922|text|我看到了“|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3826923|！”正在打印两次。析构函数的调用不应该释放对象吗?当析构函数超出作用域时，不应该再次调用它。还是有其他的概念呢？|blockquote|3826924|3826925|3826926|是这样的。|3826927|3826928|我必须提一下，我并不打算在实践中这样做。我只是想知道这是怎么回事。|3826929|3826930|3826931|你调用了析构函数，准备销毁一个对象。但这也是在对象超出作用域时，在它被实际释放之前自动完成的。|3826932|需要理解的是:如果你做了一些没有意义的事情，那么糟糕的事情就会发生。所以不要做没有意义的事情。如果手动调用析构函数，则会运行析构函数。这对其他任何东西都没有影响，除非析构函数实际做了一些有影响的事情。|3826933|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|X|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|D|7|Z|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|12|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|13|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|S|$]]

<blockquote>
 I see that "Hello!" is being printed twice. shouldn't the calling of the destructor free the object and the destructor shouldn't be called again when it goes out of scope. Or is there some other concept ?
</blockquote>

That's correct.

<blockquote>
 I must mention that im not intending to do this in practice. Im just trying to understand whats going on here.
</blockquote>

You've called the destructor, preparing an object to be destroyed. But this is also done automatically when an object goes out of scope, before it's actually de-allocated.

The thing to understand is this: If you do things that don't make sense, then bad things happen. So don't do things that don't make sense. If you manually call a destructor, the descructor runs. That has no effect on anything else unless the destructor actually does something that has an effect.

blocks|key|2149760|text|你只是调用析构函数，实际上并没有释放任何内存(它是静态分配的)。如果使用new，然后删除，析构函数将只被调用一次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2149761|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|$]]

You just call the destructor, you don't actually free any memory (it is statically allocated). If you use new and then delete the destructor will only be called once.

blocks|key|3827014|text|析构函数不是对象的“破坏者”。它只是一个普通的函数，但它是在销毁之前被语言自动调用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3827015|它的正式名称是析构函数，但如果我们将其称为“销毁前”函数，可能会更容易理解。|3827016|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The destructor is not the "destroyer" of the object. It's just an ordinary function, but it's called automatically by the language immediately prior to the time of destruction. 

It's official name is the destructor, but perhaps it would be more easily understood if we called it the "Before-Destruction" function.

blocks|key|3917464|text|您不需要调用析构函数，尽管这样做是可能的。当一个对象不再使用时，编译器应该隐式地运行你的析构函数。创建对象时，如果已使用类成员的特定初始化值声明了该对象，则将对该对象使用构造函数。当您不再需要您的对象时，您的析构函数将运行并删除成员变量声明及其值。这对于不使用自动垃圾收集的语言来说是最有用的，比如C%2B%2B。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3917465|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|$]]

You won't need to call to a destructor, although it is possible to do so. The compiler should implicitly run your destructor for you when an object is no longer used. When objects are created, your constructor is utilized for that object, if it has been declared with specific and initialized values for your class members. When you no longer need your object your destructor will run and delete member variable declarations and their values. This is most useful for languages that don't utilize automatic garbage collection, like C++.

blocks|key|2191940|text|可以调用类的析构函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2191941|2191942|Explicitly|ordered-list-item|offset|length|style|BOLD|2191943|2191944|使用类的对象显式调用析构函数时，调用class.|2191945|Implicitly的另一个成员函数的方式相同|unordered-list-item|2191946|2191947|当类的对象超出作用域或使用delete运算符销毁使用new运算符创建的对象时。|2191948|在您的示例程序中，您可以同时执行这两项操作|2191949|int+main()
{
++temp+t;

++t.~temp();+//1.+Calling+destructor+explictly+using+the+object+`t`

++return+0;
}+//+2.+object+`t`+goes+out+of+scope.+So+destructor+invoked+implictly|code-block|syntax|javascript|2191950|这就是为什么你会看到析构函数被调用两次的原因。|2191951|正如你所想的那样，析构函数将销毁构造器创建的资源。所以不应该显式调用析构函数，因为它将导致销毁已经被销毁的资源，这可能是致命的。|2191952|entityMap^0|0|0|0|A|0|0|0|0|A|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|17|8|@$F|18|G|19|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1B|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1C|8|@$F|1D|G|1E|H|I]]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1G|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1H|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|1I|8|@]|9|@]|A|$X|Y]]|$1|Z|3|10|5|6|7|1J|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|1K|8|@]|9|@]|A|$]]|$1|13|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|14|$]]

The destructor of a class could be invoked:

<ol>
<li>Explicitly

When the destructor is explicitly invoked using the object of the class, the same way you invoke another member function of the class.</li>
<li>Implicitly

When the object of the class goes out of scope or an object which is created using the new operator is destroyed using the delete operator.</li>
</ol>

In your sample program, you do both

<pre><code>int main()
{
 temp t;

 t.~temp(); //1. Calling destructor explictly using the object `t`

 return 0;
} // 2. object `t` goes out of scope. So destructor invoked implictly
</code></pre>

and that is the reason why you see the destructor being called twice.

As you have aptly thought, the destructor will destroy the resources which were created by constructor. So the destrutor should not be called explicitly, as it will result in destroying the already destroyed resource and that could be fatal.

I was experimenting with destructors in C++ with this piece of code:

<pre><code>#include &lt;iostream&gt;

struct temp
{
 ~temp() { std::cout &lt;&lt; "Hello!" &lt;&lt; std::endl; }
};

int main()
{
 temp t;
 t.~temp();
}
</code></pre>

I see that "Hello!" is being printed twice. Shouldn't the calling of the destructor free the object and the destructor shouldn't be called again when it goes out of scope? Or is there some other concept?

(I do not intend to do this in practice. I'm just trying to understand what's going on here.)

Destructor being called twice when being explicitly invoked

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我用这段代码在C++中试验析构函数：#include <iostream>struct temp{ ~temp() { std::cout << "Hello!" << std::endl; }};int main(){ temp t; t.~temp();}我看到了“你好！”正在打印两次。析构函数的...

问析构函数在显式调用时被调用两次
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问析构函数在显式调用时被调用两次EN