blocks|key|3938740|text|使用std::uncaught_exception()几乎可以做到这一点，但并不完全如此。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3938741|Herb+Sutter比我更好地解释了“几乎”：http://www.gotw.ca/gotw/047.htm|3938742|在极少数情况下，当从析构函数调用时，std::uncaught_exception()返回true，但相关对象实际上并未被堆栈展开过程销毁。|3938743|没有RAII你可能会过得更好，因为它与你的用例不匹配。RAII的意思是总是清理，不管有没有异常。|3938744|你想要的要简单得多:只有在没有抛出异常的情况下才释放资源，这是一个简单的函数序列。|3938745|explicitAllocateResource();
doSomeWorkThatMayThrowException();
explicitReleaseResource();+//+skipped+if+an+exception+is+thrown
+++++++++++++++++++++++++++//+by+the+previous+function.|code-block|syntax|javascript|3938746|entityMap|0|LINK|mutability|MUTABLE|url|http://www.gotw.ca/gotw/047.htm^0|2|P|0|O|V|0|0|I|P|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@$9|14|A|15|1|16]]|E|$]]|$1|H|3|I|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1A|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|1B|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|1C|8|@]|D|@]|E|$Q|R]]|$1|S|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

You can almost do this with <code>std::uncaught_exception()</code>, but not quite.

Herb Sutter explains the "almost" better than I do: <a href="http://www.gotw.ca/gotw/047.htm" rel="nofollow noreferrer">http://www.gotw.ca/gotw/047.htm</a>

There are corner cases where <code>std::uncaught_exception()</code> returns true when called from a destructor but the object in question isn't actually being destroyed by the stack unwinding process.

You're probably better off without RAII because it doesn't match your use case. RAII means always clean up; exception or not.

What you want is much simpler: only release resource if an exception is not throw which is a simple sequence of functions.

<pre><code>explicitAllocateResource();
doSomeWorkThatMayThrowException();
explicitReleaseResource(); // skipped if an exception is thrown
 // by the previous function.
</code></pre>

blocks|key|3938765|text|我会以另一种方式来做-明确地告诉它如果没有抛出异常就去做它的工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3938766|RAII_Class+pending;

doSomeWorkThatMayThrowException();

pending.commit();+//+do+or+prepare+actual+work|code-block|syntax|javascript|3938767|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I would do it the other way around - explicitly tell it to do its work if no exception was thrown:

<pre><code>RAII_Class pending;

doSomeWorkThatMayThrowException();

pending.commit(); // do or prepare actual work
</code></pre>

blocks|key|2530274|text|看起来像bool+std::uncaught_exception()；如果您希望对每个异常都有此行为，而不仅仅是特殊的异常，就可以做到这一点！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2530275|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|$]]

Looks like bool std::uncaught_exception(); does the trick if you want to have this behavior for every exception, not just special ones!

blocks|key|1529947|text|您可以不使用try-catch：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1529948|RAII_Class+pending;
doSomeWorkThatMayThrowException();++//+intentional:+don't+release+if+throw
pending.releaseResource();|code-block|syntax|javascript|1529949|或者，您可以更努力地使用RAII：|1529950|struct+RAII_Class+{
++++template<class+Op>
++++void+execute(Op+op)+{
++++++++op();
++++++++releaseResources();
++++}

private:
++++void+releaseResources()+{+/*+...+*/+}
};

int+main(int+argc,+char*+argv[])
{
++++RAII_Class().execute(doSomeWorkThatMayThrowException);
++++return+0;
}|1529951|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can do without a try-catch:

<pre><code>RAII_Class pending;
doSomeWorkThatMayThrowException(); // intentional: don't release if throw
pending.releaseResource();
</code></pre>

Alternatively, you can try a little harder with RAII:

<pre><code>struct RAII_Class {
 template&lt;class Op&gt;
 void execute(Op op) {
 op();
 releaseResources();
 }

private:
 void releaseResources() { /* ... */ }
};

int main(int argc, char* argv[])
{
 RAII_Class().execute(doSomeWorkThatMayThrowException);
 return 0;
}
</code></pre>

blocks|key|781090|text|这似乎绕过了使用RAII的主要原因。RAII的要点是，如果在代码中途发生异常，您仍然可以正确地释放资源/被析构。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|781091|如果这不是你想要的语义，那么不要使用RAII。|781092|因此，不是：|781093|void+myFunction()+{
++++WrapperClass+wc(acquireResource());

++++//+code+that+may+throw
}|code-block|syntax|javascript|781094|只需这样做：|781095|void+myFunction()+{
++++Resource+r+=+acquireResource();

++++//+code+that+may+throw

++++freeResource(r);
}|781096|如果中间的代码抛出，资源将不会被释放。这就是您想要的，而不是保留RAII+(并保留名称)，而不是实现RAII语义。|781097|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

This seems to circumvent the main reason to use RAII. The point of RAII is that if an exception happens in the middle of your code you can still release resources/be destructed properly.

If this isn;t the semantic you want, then don't use RAII. 

So instead of:

<pre><code>void myFunction() {
 WrapperClass wc(acquireResource());

 // code that may throw
}
</code></pre>

Just do:

<pre><code>void myFunction() {
 Resource r = acquireResource();

 // code that may throw

 freeResource(r);
}
</code></pre>

If the code in the middle throws, the resource won't be freed. This is what you want, rather than keeping RAII (and keeping the name) but not implementing RAII semantics.

blocks|key|783951|text|我发现这个网站有一个关于std::uncaught_exception()的有趣讨论，以及对你的问题的另一种解决方案，对我来说似乎更优雅和正确：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|783952|http://www.gotw.ca/gotw/047.htm|offset|length|783953|//++Alternative+right+solution
//
T::Close()+{
++//+...+code+that+could+throw+...
}

T::~T()+/*+throw()+*/+{
++try+{
++++Close();
++}+catch(+...+)+{
++}
}|code-block|syntax|javascript|783954|通过这种方式，你的析构函数只做一件事，并且你可以避免在异常期间抛出异常(我认为这就是你试图解决的问题)。|783955|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|V|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@$D|V|E|W|1|X]]|A|$]]|$1|F|3|G|5|H|7|Y|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|Z|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|C]]]]

I found this website with an interesting discussion about std::uncaught_exception() and an alternative solution to your question that seems much more elegant and correct to me:

<a href="http://www.gotw.ca/gotw/047.htm" rel="nofollow noreferrer">http://www.gotw.ca/gotw/047.htm</a>

<pre><code>// Alternative right solution
//
T::Close() {
 // ... code that could throw ...
}

T::~T() /* throw() */ {
 try {
 Close();
 } catch( ... ) {
 }
}
</code></pre>

In this way you're destructor does only one thing and you're protected against throwing an exception during an exception (which I assume is the problem you're trying to solve).

blocks|key|3938960|text|虽然这充其量是一件笨拙的事情，但如果您拥有感兴趣的exception类的代码，您可以向该类添加一个静态数据成员(bool)，该成员将在该类的对象的构造函数中设置为"true“，在析构函数中设置为false+(可能需要为一个可递增/递减的int+)。然后，在RAII类的析构函数中，可以检查std::uncaught_exception()，如果为真，则查询异常类中的静态数据成员。如果返回值为true+(或>+0)，则说明出现了这些异常之一--否则将忽略它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3938961|不是很优雅，但它可能会做到这一点(只要你没有多个线程)。|3938962|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|$]]

Although it would be a kludge at best, if you own the code for the exception class you're interested in, you could add a static data member to that class (bool) that would be set to "true" in the constructor for objects of that class, and false in the destructor (might need to be an int that you increment/decrement instead). Then in the destructor of your RAII class, you can check std::uncaught_exception(), and if true, query the static data member in your exception class. If you get true (or > 0) back, you've got one of those exceptions--otherwise you ignore it.

Not very elegant, but it would probably do the trick (as long as you don't have multiple threads).

I have an object on the stack for which I wish its destructor to skip some work when the destructor is being called because the stack is being unwound due to a specific exception being thrown through the scope of the object on the stack.

Now I could add a try catch block inside the scope of the stack item and catch the exception in question and notify the stack object to not run the work to be skipped an then rethrow the exception as follows:

<pre><code>RAII_Class pending;

try {
 doSomeWorkThatMayThrowException();
} catch (exceptionToSkipPendingDtor &amp;err) {
 pending.notifySkipResourceRelease();
 throw;
}
</code></pre>

However, I'm hoping there is a more elegant way to do this. For example imagine:

<pre><code>RAII_Class::~RAII_Class {
 if (detectExceptionToSkipPendingDtorBeingThrown()) {
 return;
 }
 releaseResource();
}
</code></pre>

Way for C++ destructor to skip work when specific exception being thrown?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我在堆栈上有一个对象，我希望它的析构函数在调用析构函数时跳过一些工作，因为由于在堆栈上的对象的作用域中抛出了一个特定的异常，所以正在展开堆栈。现在，我可以在stack项的作用域中添加try catch块，捕获有问题的异常，并通知stack对象不要运行要跳过的工作，然后重新抛出异常，如下所示：RAII_Class pen...

问当抛出特定异常时，C++析构函数跳过工作的方法？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当抛出特定异常时，C++析构函数跳过工作的方法？EN