需要在构造函数中进行 try catch

Question

链接 http://gotw.ca/gotw/066.htm 指出

道德#1：构造函数尝试块处理程序只有一个目的——转换异常。 （也许还可以进行日志记录或其他一些副作用。）它们对任何其他目的没有用处。

而 http://www.parashift.com/c++-faq- lite/exceptions.html#faq-17.8

如果构造函数抛出异常，则不会运行该对象的析构函数。如果您的对象已经完成了需要撤消的操作（例如分配一些内存、打开文件或锁定信号量），则必须由对象内的数据成员记住此“需要撤消的操作”。

这2种说法不矛盾吗？第一种暗示构造函数中的 try catch 几乎没有用，而第二种则表示需要释放资源。我在这里缺少什么？

Answer 1

道德#1 谈论function-try-block &第二个声明谈论的是普通的try catch块，两者明显不同。

您需要了解两者之间的区别才能理解这两个句子的意义。 这个在这里回答解释说。

Answer 2

它们指的是不同的事物。

第一个与函数 try 块相关，即包含整个函数的 try 块，并且在构造函数的情况下，还包括对基类和成员对象的构造函数，即在实际构造函数主体运行之前执行的内容。

其精神是，如果基类或类成员无法正确构造，则对象构造必须失败并出现异常，因为否则新构造的对象将处于与基类不一致的状态对象/成员对象已构建一半。因此，此类 try 块的目的必须只是转换/重新抛出此类异常，也许会记录事件。您不能以任何其他方式执行此操作：如果您没有在 catch 中显式 throw ，则隐式 throw; 会由编译器以防止“半构造对象”的可能性。

第二个是指在你的构造函数体内引发的异常；在这种情况下，它表示您应该使用“常规”try 块来捕获异常，释放到目前为止分配的资源，然后重新抛出，因为不会调用析构函数。

请注意，这种行为是有道理的，因为析构函数的隐式契约（与任何其他非构造函数的成员函数一样）是它期望以一致的状态处理对象；但是构造函数抛出异常意味着该对象尚未完全构造，因此会违反此约定。

Answer 3

对于简单术语的模糊翻译是：函数尝试块只能用于翻译异常并且始终使用RAII，并且每个资源应该由一个单个对象，并且它们并不矛盾。哦，好吧，翻译并不完全是这样，但论证最终得出了这两个结论。

来自 C++FAQ lite 的第二句话指出，对于构造函数未完成的对象，不会调用析构函数。这反过来意味着，如果您的对象正在管理资源，尤其是当它管理多个资源时，您就会陷入大麻烦。您可以在异常逃逸构造函数之前捕获该异常，然后尝试释放已获取的资源，但为此您需要知道实际分配了哪些资源。

第一个引用说构造函数中的函数 try 块必须抛出（或重新抛出），因此它的用处非常有限，特别是它能做的唯一有用的事情就是翻译异常。请注意，函数 try 块的唯一原因是在执行初始化列表期间捕获异常。

但是等等，函数 try 块不是处理第一个问题的方法吗？

嗯...不是真的。考虑一个具有两个指针并在其中存储内存的类。并考虑第二次调用可能会失败，在这种情况下我们需要释放第一个块。我们可以尝试用两种不同的方式来实现它，使用函数 try 块或使用常规 try 块：

// regular try block                       // function try block
struct test {
   type * p;
   type * q; 
   test() : p(), q() {                     test() try : p( new int ), q( new int ) {
      try {
          p = new type;
          q = new type;
      } catch (...) {                      } catch (...) {
          delete p;                            delete p;
          throw;
      }                                    } // exception is rethrown here
   }
   ~test() { delete p; delete q; }
};

我们可以首先分析简单的情况：常规 try 块。 first 中的构造函数将两个指针初始化为 null（初始化列表中的：p()、q()），然后尝试为这两个对象创建内存。在这两个新类型之一中，会引发异常并进入 catch 块。 什么new失败了？我们不在乎，如果是第二个new失败，那么delete实际上会释放p< /代码>。如果是第一个，因为初始化列表首先将两个指针设置为 0 并且在空指针上调用 delete 是安全的，所以 delete p<如果第一个新操作失败，/code> 是一个安全的操作。

现在看右边的例子。我们已将资源分配移至初始化列表，因此我们使用函数 try 块，这是捕获异常的唯一方法。再次，其中一个消息失败了。如果第二次 new 失败，delete p 将释放该指针中分配的资源。但如果是第一个 new 失败，则 p 从未被初始化，并且对 delete p 的调用是未定义的行为。

回到我的松散翻译，如果您使用 RAII 并且每个对象仅一个资源，我们会将类型编写为：

struct test {
   std::auto_ptr<type> p,q;
   test() : p( new type ), q( new type )
   {}
};

在这个修改后的示例中，因为我们正在使用 RAII，所以我们并不真正关心例外。如果第一个 new 抛出异常，则不会获取任何资源，也不会发生任何事情。如果第二次抛出失败，则 p 将被销毁，因为在第二个 new 之前 p 已完全构造已尝试（那里有序列点），并且资源将被释放。

因此，我们甚至不需要 try 来管理资源...这给我们留下了 Sutter 提到的其他用法：翻译异常。虽然我们必须抛出失败的构造函数，但我们可以选择抛出什么。我们可能决定抛出一个自定义的initialization_error，无论构造中的内部故障是什么。这就是函数 try 块的用途：

struct test {
   std::auto_ptr<type> p,q;
   test()  try : p( new type ), q( new type ) {
   } catch ( ... ) {
      throw initialization_error();
   }
};

Answer 4

这两种说法不矛盾吗？

不。第二个基本上意味着如果构造函数抛出一个来自它（即构造函数）的异常，那么析构函数不会被调用。第一个意味着 function-try-block 不会让异常从构造函数中出来。它在构造函数本身内部捕获它，并在那里处理它。

Answer 5

首先，构造函数 try-block 与构造函数中的 try-catch 不同。

其次，说“需要撤消的事情必须由数据成员记住”与说“使用 try-catch 块来撤消事情”不同。

这两种说法并不矛盾，只是说的是不同的事情。事实上，第二个根本不是在谈论 try-catch。