blocks|key|187169|text|不，你不应该显式调用它，因为它会被调用两次。一次用于手动调用，另一次是在声明对象的范围结束时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|187170|例如：|187171|{
++Class+c;
++c.~Class();
}|code-block|syntax|javascript|187172|如果你真的需要执行同样的操作，你应该有一个单独的方法。|187173|有一个specific+situation，您可能想要使用放置new调用动态分配的对象上的析构函数，但它听起来并不是您所需要的。|offset|length|style|CODE|187174|entityMap|0|LINK|mutability|MUTABLE|url|http://www.parashift.com/c%2B%2B-faq/placement-new.html^0|0|0|0|0|V|3|3|I|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|12|8|@$M|13|N|14|O|P]]|9|@$M|15|N|16|1|17]]|A|$]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

No, you shouldn't call it explicitly because it would be called twice. Once for the manual call and another time when the scope in which the object is declared ends.

Eg.

<pre><code>{
 Class c;
 c.~Class();
}
</code></pre>

If you really need to perform the same operations you should have a separate method.

There is a <a href="http://www.parashift.com/c++-faq/placement-new.html" rel="noreferrer">specific situation</a> in which you may want to call a destructor on a dynamically allocated object with a placement <code>new</code> but it doesn't sound something you will ever need.

blocks|key|187210|text|我从来没有遇到过需要手动调用析构函数的情况。我似乎记得，甚至连Stroustrup都声称这是一种糟糕的做法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|187211|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|$]]

I have never come across a situation where one needs to call a destructor manually. I seem to remember even Stroustrup claims it is bad practice.

blocks|key|405442|text|在某些情况下，它们是必要的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|405443|在我工作的代码中，我在分配器中使用显式析构函数调用，我实现了一个简单的分配器，它使用新的位置将内存块返回到stl容器。在毁灭中，我有：|405444|++void+destroy+(pointer+p)+{
++++//+destroy+objects+by+calling+their+destructor
++++p->~T();
++}|code-block|syntax|javascript|405445|在构造过程中：|405446|++void+construct+(pointer+p,+const+T&+value)+{
++++//+initialize+memory+with+placement+new
++++#undef+new
++++::new((PVOID)p)+T(value);
++}|405447|还可以使用特定于平台的alloc和dealloc机制，在allocation+()中进行分配，在allocate()中进行内存释放。这个分配器被用来绕过doug+lea+malloc，直接使用，例如windows上的LocalAlloc。|405448|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

There are cases when they are necessary:

In code I work on I use explicit destructor call in allocators, I have implementation of simple allocator that uses placement new to return memory blocks to stl containers. In destroy I have:

<pre><code> void destroy (pointer p) {
 // destroy objects by calling their destructor
 p-&gt;~T();
 }
</code></pre>

while in construct:

<pre><code> void construct (pointer p, const T&amp; value) {
 // initialize memory with placement new
 #undef new
 ::new((PVOID)p) T(value);
 }
</code></pre>

there is also allocation being done in allocate() and memory deallocation in deallocate(), using platform specific alloc and dealloc mechanisms. This allocator was used to bypass doug lea malloc and use directly for example LocalAlloc on windows.

blocks|key|187329|text|无论何时需要将分配与初始化分开，您都需要手动放置新的和显式调用析构函数。今天，它很少是必要的，因为我们有标准的容器，但如果你必须实现某种新的容器，你将需要它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|187330|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|$]]

Any time you need to separate allocation from initialization,
you'll need placement new and explicit calling of the destructor
manually. Today, it's rarely necessary, since we have the
standard containers, but if you have to implement some new sort
of container, you'll need it.

blocks|key|405544|text|在另一种情况下，我认为调用析构函数是完全合理的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|405545|在编写"+reset“类型的方法来将对象恢复到其初始状态时，调用析构函数来删除正在被重置的旧数据是完全合理的。|405546|class+Widget
{
private:+
++++char*+pDataText+{+NULL++};+
++++int+++idNumber++{+0+++++};

public:
++++void+Setup()+{+pDataText+=+new+char[100];+}
++++~Widget()++++{+delete+pDataText;++++++++++}

++++void+Reset()
++++{
++++++++Widget+blankWidget;
++++++++this->~Widget();+++++//+Manually+delete+the+current+object+using+the+dtor
++++++++*this+=+blankObject;+//+Copy+a+blank+object+to+the+this-object.
++++}
};|code-block|syntax|javascript|405547|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I have another situation where I think it is perfectly reasonable to call the destructor.

When writing a "Reset" type of method to restore an object to its initial state, it is perfectly reasonable to call the Destructor to delete the old data that is being reset.

<pre><code>class Widget
{
private: 
 char* pDataText { NULL }; 
 int idNumber { 0 };

public:
 void Setup() { pDataText = new char[100]; }
 ~Widget() { delete pDataText; }

 void Reset()
 {
 Widget blankWidget;
 this-&gt;~Widget(); // Manually delete the current object using the dtor
 *this = blankObject; // Copy a blank object to the this-object.
 }
};
</code></pre>

blocks|key|187454|text|那这个呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|187455|如果构造函数抛出异常，则不会调用析构函数，因此我必须手动调用它来销毁在异常之前在构造函数中创建的句柄。|187456|class+MyClass+{
++HANDLE+h1,h2;
++public:
++MyClass()+{
++++//+handles+have+to+be+created+first
++++h1=SomeAPIToCreateA();
++++h2=SomeAPIToCreateB();++++++++
++++try+{
++++++...
++++++if(error)+{
++++++++throw+MyException();
++++++}
++++}
++++catch(...)+{
++++++this->~MyClass();
++++++throw;
++++}
++}
++~MyClass()+{
++++SomeAPIToDestroyA(h1);
++++SomeAPIToDestroyB(h2);
++}
};|code-block|syntax|javascript|187457|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

What about this? 
Destructor is not called if an exception is thrown from the constructor, so I have to call it manually to destroy handles that have been created in the constructor before the exception.

<pre><code>class MyClass {
 HANDLE h1,h2;
 public:
 MyClass() {
 // handles have to be created first
 h1=SomeAPIToCreateA();
 h2=SomeAPIToCreateB(); 
 try {
 ...
 if(error) {
 throw MyException();
 }
 }
 catch(...) {
 this-&gt;~MyClass();
 throw;
 }
 }
 ~MyClass() {
 SomeAPIToDestroyA(h1);
 SomeAPIToDestroyB(h2);
 }
};
</code></pre>

blocks|key|405607|text|发现了另一个必须手动调用析构函数的示例。假设您已经实现了一个类似variant的类，它包含以下几种类型的数据之一：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|405608|struct+Variant+{
++++union+{
++++++++std::string+str;
++++++++int+num;
++++++++bool+b;
++++};
++++enum+Type+{+Str,+Int,+Bool+}+type;
};|code-block|syntax|javascript|405609|如果Variant实例持有一个std::string，而您现在为联合分配了一个不同的类型，则必须首先析构该std::string。The+compiler+will+not+do+that+automatically。|offset|length|style|CODE|405610|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/language/union#Explanation^0|0|0|2|7|F|B|1H|B|1T|17|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]]|9|@$I|13|J|14|1|15]]|A|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Found another example where you would have to call destructor(s) manually. Suppose you have implemented a variant-like class that holds one of several types of data:

<pre><code>struct Variant {
 union {
 std::string str;
 int num;
 bool b;
 };
 enum Type { Str, Int, Bool } type;
};
</code></pre>

If the <code>Variant</code> instance was holding a <code>std::string</code>, and now you're assigning a different type to the union, you must destruct the <code>std::string</code> first. <a href="https://en.cppreference.com/w/cpp/language/union#Explanation" rel="nofollow noreferrer">The compiler will not do that automatically</a>.

I was thinking: they say if you're calling destructor manually - you're doing something wrong. But is it always the case? Are there any counter-examples? Situations where it is neccessary to call it manually or where it is hard/impossible/impractical to avoid it?

Is calling destructor manually always a sign of bad design?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我在想:他们说如果你手动调用析构函数--你做错了什么。但情况总是这样吗？有什么反例吗？需要手动调用它，或者很难/不可能/不切实际地避免它的情况？

问手动调用析构函数总是糟糕设计的标志吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问手动调用析构函数总是糟糕设计的标志吗？EN