Herb Sutter在这里写过这个问题。绝对值得一读。 摘要:

"Writing exception-safe code is fundamentally about writing 'try' and 'catch' in the correct places." Discuss. Put bluntly, that statement reflects a fundamental misunderstanding of exception safety. Exceptions are just another form of error reporting, and we certainly know that writing error-safe code is not just about where to check return codes and handle error conditions. Actually, it turns out that exception safety is rarely about writing 'try' and 'catch' -- and the more rarely the better. Also, never forget that exception safety affects a piece of code's design; it is never just an afterthought that can be retrofitted with a few extra catch statements as if for seasoning.

You don't need to cover every block with try-catches because a try-catch can still catch unhandled exceptions thrown in functions further down the call stack. So rather than have every function have a try-catch, you can have one at the top level logic of your application. For example, there might be a SaveDocument() top-level routine, which calls many methods which call other methods etc. These sub-methods don't need their own try-catches, because if they throw, it's still caught by SaveDocument()'s catch.

这样做很好，有三个原因:它很方便，因为只有一个地方可以报告错误:SaveDocument()捕获块。没有必要在所有子方法中重复这一点，而且这正是您想要的:在一个单一的位置为用户提供关于出错的有用诊断。

第二，每当抛出异常时，保存将被取消。对于每个尝试捕获子方法，如果抛出异常，则进入该方法的捕获块，执行离开函数，并通过SaveDocument()继续进行。如果事情已经出了问题，你可能会想就此打住。

第三，所有子方法都可以假设每次调用都成功。如果调用失败，执行将跳转到catch块，后续代码永远不会执行。这可以使您的代码更加清晰。例如，下面是错误代码:

int ret = SaveFirstSection();

if (ret == FAILED)
{
    /* some diagnostic */
    return;
}

ret = SaveSecondSection();

if (ret == FAILED)
{
    /* some diagnostic */
    return;
}

ret = SaveThirdSection();

if (ret == FAILED)
{
    /* some diagnostic */
    return;
}

下面是如何编写例外情况:

// these throw if failed, caught in SaveDocument's catch
SaveFirstSection();
SaveSecondSection();
SaveThirdSection();

现在发生了什么更加清楚了。

注意，以其他方式编写异常安全代码可能更加棘手:如果抛出异常，您不希望泄漏任何内存。确保你了解RAII、STL容器、智能指针和其他在析构函数中释放资源的对象，因为对象总是在异常之前被析构。

Herb Sutter在这里写过这个问题。绝对值得一读。 摘要:

"Writing exception-safe code is fundamentally about writing 'try' and 'catch' in the correct places." Discuss. Put bluntly, that statement reflects a fundamental misunderstanding of exception safety. Exceptions are just another form of error reporting, and we certainly know that writing error-safe code is not just about where to check return codes and handle error conditions. Actually, it turns out that exception safety is rarely about writing 'try' and 'catch' -- and the more rarely the better. Also, never forget that exception safety affects a piece of code's design; it is never just an afterthought that can be retrofitted with a few extra catch statements as if for seasoning.

我同意你的问题的基本方向，即在最低级别处理尽可能多的异常。

一些现有的回答是这样的:“您不需要处理异常。别人会在上面做的。”根据我的经验，这是一个不考虑当前开发的代码段异常处理的糟糕借口，让异常处理其他人或以后的问题。

在分布式开发中，这个问题会急剧增加，在分布式开发中，您可能需要调用由同事实现的方法。然后，您必须检查嵌套的方法调用链，以找出他/她为什么向您抛出一些异常，这在嵌套最深的方法中可以更容易地处理。

I was given the "opportunity" to salvage several projects and executives replaced the entire dev team because the app had too many errors and the users were tired of the problems and run-around. These code bases all had centralized error handling at the app level like the top voted answer describes. If that answer is the best practice why didn't it work and allow the previous dev team to resolve issues? Perhaps sometimes it doesn't work? The answers above don't mention how long devs spend fixing single issues. If time to resolve issues is the key metric, instrumenting code with try..catch blocks is a better practice.

How did my team fix the problems without significantly changing the UI? Simple, every method was instrumented with try..catch blocked and everything was logged at the point of failure with the method name, method parameters values concatenated into a string passed in along with the error message, the error message, app name, date, and version. With this information developers can run analytics on the errors to identify the exception that occurs the most! Or the namespace with the highest number of errors. It can also validate that an error that occurs in a module is properly handled and not caused by multiple reasons.

Another pro benefit of this is developers can set one break-point in the error logging method and with one break-point and a single click of the "step out" debug button, they are in the method that failed with full access to the actual objects at the point of failure, conveniently available in the immediate window. It makes it very easy to debug and allows dragging execution back to the start of the method to duplicate the problem to find the exact line. Does centralized exception handling allow a developer to replicate an exception in 30 seconds? No.

语句“方法只有在能够以某种合理的方式处理异常时才应该捕获异常。”这意味着开发人员可以预测或将遇到在发布之前可能发生的每一个错误。如果这是真的，那么应用程序异常处理程序就不需要了，Elastic Search和logstash也就没有市场了。

这种方法还可以让开发人员发现并修复生产中的间歇性问题!是否希望在生产环境中不使用调试器进行调试?或者你宁愿接那些心烦意乱的用户的电话和邮件?这可以让你在其他人知道之前解决问题，而不必通过电子邮件、即时通讯或Slack寻求支持，因为解决问题所需的一切都在那里。95%的问题永远不需要被复制。

为了正常工作，它需要与集中式日志记录相结合，该日志记录可以捕获名称空间/模块、类名、方法、输入和错误消息并存储在数据库中，以便可以聚合它以突出显示哪个方法失败最多，以便首先修复它。

有时候开发人员会选择从catch块向堆栈抛出异常，但这种方法比不抛出异常的普通代码慢100倍。优先使用日志记录进行捕获和释放。

在一家财富500强公司中，该技术被用于快速稳定一款每小时都会出现故障的应用，该应用是由12名开发者历时2年开发的。使用这3000个不同的异常在4个月内被识别、修复、测试和部署。这平均每15分钟修复一次，持续4个月。

我同意，输入所有需要的代码并不有趣，我更喜欢不看重复的代码，但从长远来看，为每个方法添加4行代码是值得的。

我想在这个讨论中补充一点，自从c++ 11以来，它确实很有意义，只要每个catch块重新抛出异常，直到它可以/应该被处理为止。通过这种方式可以生成反向跟踪。因此，我认为前面的观点在某种程度上已经过时了。

使用std::nested_exception和std::throw_with_nested

在这里和这里的StackOverflow描述了如何实现这一点。

由于可以对任何派生异常类执行此操作，因此可以向这样的回溯添加大量信息! 你也可以看看我在GitHub上的MWE，在那里回溯看起来是这样的:

Library API: Exception caught in function 'api_function'
Backtrace:
~/Git/mwe-cpp-exception/src/detail/Library.cpp:17 : library_function failed
~/Git/mwe-cpp-exception/src/detail/Library.cpp:13 : could not open file "nonexistent.txt"