如果您想测试每个函数的结果，请使用返回码。

exception的目的是为了降低测试结果的频率。其思想是将异常(不寻常的，罕见的)条件从更普通的代码中分离出来。这使得普通代码更简洁，但仍然能够处理那些异常情况。

在设计良好的代码中，较深的函数可能会抛出，较高级的函数可能会捕获。但关键是，许多“介于两者之间”的功能将完全摆脱处理异常情况的负担。它们只需要是“异常安全的”，这并不意味着它们必须捕获。

我想在这个讨论中补充一点，自从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"

尽管Mike Wheat的回答很好地总结了要点，但我还是觉得有必要再补充一个答案。我是这样想的。当你有方法做很多事情时，你是在增加复杂性，而不是增加它。

换句话说，封装在try catch中的方法有两种可能的结果。有非异常结果和异常结果。当你处理很多方法的时候这个指数级的爆炸超出了你的理解。

因为如果每个方法都以两种不同的方式分支，那么每次调用另一个方法时，你都是在对之前的潜在结果数进行平方。当你调用了5个方法时，你至少有256个可能的结果。与此相比，在每个方法中都不执行try/catch，您只有一条路径可以遵循。

我基本上就是这么看的。您可能会认为任何类型的分支都做同样的事情，但try/catch是一个特殊情况，因为应用程序的状态基本上是未定义的。

简而言之，try/catch使代码更难理解。

因为下一个问题是“我已经捕获了一个异常，接下来我该做什么?”你会怎么做?如果你什么都不做——这是错误隐藏，程序可能“就是不能工作”，没有任何机会发现发生了什么。您需要了解捕获异常后要做什么，并且只有在知道的情况下才进行捕获。

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容器、智能指针和其他在析构函数中释放资源的对象，因为对象总是在异常之前被析构。