你的问题表明，“编写异常安全的代码非常困难”。我先回答你的问题，然后再回答背后隐藏的问题。
回答问题
你真的写异常安全的代码吗?
我当然知道。
这就是Java对作为c++程序员的我失去吸引力的原因(缺乏RAII语义)，但我离题了:这是一个c++问题。
事实上，当您需要使用STL或Boost代码时，这是必要的。例如，c++线程(boost::thread或std::thread)将抛出异常以优雅地退出。
您确定最后的“生产就绪”代码是异常安全的吗?
你能确定这是真的吗?
编写异常安全的代码就像编写没有bug的代码。
你不能100%确定你的代码是异常安全的。但是，您要努力做到这一点，使用众所周知的模式，避免众所周知的反模式。
你知道和/或实际上使用有效的替代方法吗?
c++中没有可行的替代方案(也就是说，你需要恢复到C，避免c++库，以及像Windows SEH这样的外部惊喜)。
编写异常安全代码
要编写异常安全的代码，首先必须知道所编写的每条指令的异常安全级别。
例如，new可以抛出异常，但赋值内置对象(例如int或指针)不会失败。交换永远不会失败(不要写抛出交换)，std::list::push_back可以抛出…
除了保证
首先要理解的是，你必须能够计算所有函数提供的异常保证:
none: Your code should never offer that. This code will leak everything, and break down at the very first exception thrown.
basic: This is the guarantee you must at the very least offer, that is, if an exception is thrown, no resources are leaked, and all objects are still whole
strong: The processing will either succeed, or throw an exception, but if it throws, then the data will be in the same state as if the processing had not started at all (this gives a transactional power to C++)
nothrow/nofail: The processing will succeed.
代码示例
下面的代码看起来像是正确的c++，但实际上，它提供了“none”保证，因此，它是不正确的:
void doSomething(T & t)
{
if(std::numeric_limits<int>::max() > t.integer) // 1. nothrow/nofail
t.integer += 1 ; // 1'. nothrow/nofail
X * x = new X() ; // 2. basic : can throw with new and X constructor
t.list.push_back(x) ; // 3. strong : can throw
x->doSomethingThatCanThrow() ; // 4. basic : can throw
}
我在编写所有代码时都考虑到这种分析。
提供的最低保证是基本的，但随后，每条指令的顺序使整个函数为“none”，因为如果3。抛出，x会泄漏。
首先要做的是将函数设置为“basic”，即将x放入智能指针中，直到它被列表安全地拥有:
void doSomething(T & t)
{
if(std::numeric_limits<int>::max() > t.integer) // 1. nothrow/nofail
t.integer += 1 ; // 1'. nothrow/nofail
std::auto_ptr<X> x(new X()) ; // 2. basic : can throw with new and X constructor
X * px = x.get() ; // 2'. nothrow/nofail
t.list.push_back(px) ; // 3. strong : can throw
x.release() ; // 3'. nothrow/nofail
px->doSomethingThatCanThrow() ; // 4. basic : can throw
}
现在，我们的代码提供了一个“基本”保证。不会有任何泄漏，所有对象都将处于正确的状态。但我们可以提供更多，也就是强有力的保证。这就是它可能变得昂贵的地方，这就是为什么不是所有的c++代码都是强大的。让我们试试吧:
void doSomething(T & t)
{
// we create "x"
std::auto_ptr<X> x(new X()) ; // 1. basic : can throw with new and X constructor
X * px = x.get() ; // 2. nothrow/nofail
px->doSomethingThatCanThrow() ; // 3. basic : can throw
// we copy the original container to avoid changing it
T t2(t) ; // 4. strong : can throw with T copy-constructor
// we put "x" in the copied container
t2.list.push_back(px) ; // 5. strong : can throw
x.release() ; // 6. nothrow/nofail
if(std::numeric_limits<int>::max() > t2.integer) // 7. nothrow/nofail
t2.integer += 1 ; // 7'. nothrow/nofail
// we swap both containers
t.swap(t2) ; // 8. nothrow/nofail
}
我们重新排序操作，首先创建X并将其设置为正确的值。如果任何操作失败，那么t就不会被修改，因此，操作1到3可以被认为是“强”的:如果抛出一些东西，t不会被修改，X也不会泄漏，因为它属于智能指针。
然后，我们创建t的一个副本t2，并从操作4到7处理这个副本。如果有东西抛出，t2被修改，但是t仍然是原来的。我们仍然提供强有力的保证。
然后我们交换t和t2。交换操作在c++中应该是nothrow的，所以让我们希望你为T写的交换是nothrow的(如果不是，重写它，使它是nothrow的)。
因此，如果我们到达函数的末尾，一切都成功了(不需要返回类型)，t有它的例外值。如果失败了，那么t仍然是它原来的值。
现在，提供强保证可能是相当昂贵的，所以不要努力为您的所有代码提供强保证，但如果您可以做到这一点而不花费成本(并且c++内联和其他优化可以使上述所有代码都不花费成本)，那么就这样做。函数用户会为此感谢你。
结论
编写异常安全代码需要一些习惯。您将需要评估您将使用的每个指令所提供的保证，然后，您将需要评估一个指令列表所提供的保证。
当然，c++编译器不会备份这个保证(在我的代码中，我以@warning doxygen标签的形式提供了这个保证)，这有点令人遗憾，但它不应该阻止您尝试编写异常安全的代码。
正常故障vs. bug
程序员如何保证一个没有失败的函数总是成功?毕竟，这个函数可能有bug。
这是真的。异常保证应该由无bug的代码提供。但是，在任何语言中，调用函数都假定该函数没有错误。任何理智的代码都不能保护自己不出现错误。尽你所能写出最好的代码，然后，假设它是无错误的，并提供保证。如果有bug，就改正它。
异常是针对异常处理失败，而不是针对代码错误。
最后一句话
现在的问题是“这值得吗?”
当然是这样。拥有一个“nothrow/no-fail”函数，并且知道该函数不会失败是一个很大的福音。“强”函数也可以这样说，它允许您编写具有事务语义的代码，如数据库，具有提交/回滚特性，提交是代码的正常执行，抛出异常是回滚。
那么，“基本”是你应该提供的最起码的保证。c++是一种非常强大的语言，它的作用域使您能够避免任何资源泄漏(垃圾收集器将很难为数据库、连接或文件句柄提供这种泄漏)。
所以，在我看来，这是值得的。
编辑2010-01-29:关于非抛出交换
nobar做了一个评论，我相信，是相当相关的，因为它是“如何编写异常安全代码”的一部分:
交换永远不会失败(甚至不要写抛出交换)
对于自定义编写的swap()函数，这是一个很好的建议。但是，应该注意的是，std::swap()可能会因其内部使用的操作而失败
默认的std::swap将生成副本和赋值，对于某些对象，可以抛出。因此，默认交换可能会抛出，用于您的类，甚至用于STL类。就c++标准而言，vector、deque和list的交换操作不会抛出，而如果比较函数可以在复制构造时抛出，则map的交换操作可以抛出(参见c++编程语言特别版，附录E, E. 4.3.swap)。
查看Visual c++ 2008对vector交换的实现，如果两个vector具有相同的分配器(即正常情况)，则vector交换不会抛出，但如果它们具有不同的分配器，则会生成副本。因此，我假设它会在最后一种情况下出现。
因此，原始文本仍然有效:永远不要编写抛出交换，但必须记住nobar的注释:确保您正在交换的对象具有非抛出交换。
编辑2011-11-06:有趣的文章
Dave Abrahams为我们提供了basic/strong/nothrow保证，他在一篇文章中描述了他使STL异常安全的经验:
http://www.boost.org/community/exception_safety.html
看看第7点(异常安全的自动化测试)，他依赖于自动化单元测试来确保每个用例都经过了测试。我想这部分是对作者问题“你能确定吗?”的一个很好的回答。
编辑2013-05-31:来自dionadar的评论
T.integer += 1;是没有保证溢出不会发生not异常安全，实际上可能在技术上调用UB!(有符号溢出是UB: c++ 11 5/4 "如果在表达式求值期间，结果不是数学上定义的，或者不在其类型的可表示值范围内，则行为未定义。")注意无符号整数不会溢出，而是在模2^#位的等价类中进行计算。
Dionadar指的是下面这行，它确实具有未定义的行为。
t.integer += 1 ; // 1. nothrow/nofail
这里的解决方案是在进行加法之前验证该整数是否已经达到其最大值(使用std::numeric_limits<T>::max())。
我的错误会出现在“正常失败vs. bug”部分，也就是说，一个bug。
它不会使推理失效，也不意味着异常安全代码因为不可能实现而毫无用处。
你无法保护自己不受电脑关机、编译器错误、甚至你自己的错误或其他错误的影响。你不可能达到完美，但你可以尽量接近。
我根据Dionadar的注释修正了代码。
