处理从 CTOR 抛出的异常？

Question

tl;博士

我想做这样的事情：

foo()
{
  Y* p;
  try {
    p = new Y();
  } catch {
    //fix any problem that may have occured
  }
  // Now I know the object was fixed during catch or simply was created successfully.
  p.do_something();
  // win
}

我正在创建的对象正在使用一种有时不可靠的永恒资源。在没有必要预防措施的情况下尝试分配是很危险的。如果它确实失败了，有些事情是可以做的。但是，与我稍后展示的 switch 语句不同，似乎抛出异常不允许我解决 AFAIK 问题。

有人建议我从构造函数中抛出异常。但是，我不明白这如何证明是有用的，因为我看不到该异常将如何处理？我进行了搜索并找到了this example，但我不确定它是否真的是一种有用的可扩展方式来处理构造失败。

示例代码：

void f()
{
  X x;             //← if X::X() throws, the memory for x itself will not leak
  Y* p = new Y();  //← if Y::Y() throws, the memory for *p itself will not leak
}

假设在p 之前分配的堆上的实例更多。他们不会因此而泄漏到内存中吗？所以函数f只是用来构造Y的一个实例。将“危险”构造移到另一种方法之外不是总是更有用吗？

我通常会做什么：

X* x = new X(); //No dangerous operation

switch (x.init()) // init returns int
  {
    case ...
    // Handle failed init() here
  }

这样做有缺点吗？好像比较靠谱。

Answer 1

您应该在每个成员上使用RAII（资源获取是初始化）。仅当构造函数完成时才调用对象的析构函数。这样，如果只调用两个成员的构造函数中的一个，则只会调用该成员的析构函数，并在其中执行任何清理操作。

class Locked_file_handle {
    File_ptr p;
    unique_lock<mutex> lck;
public:
    X(const char* file, mutex& m)
        :p{file, "rw"},
        lck{m} 
    {}
    // ..
};

如果在 p 构造之后但在 lck 之前发生异常，则将调用 p 而不是 lck 的析构函数。这样做可以让构造函数的作者放弃编写显式的异常处理代码。

来源：“C++ 编程语言第 4 版”（Stroustrup）

编辑：所以在你的情况下，它看起来像这样

public class YHandle {
    Y* p;
    YHandle() {
        Y = new Y()
    }
    ~YHandle() {
        delete Y;
    }
}

foo() {
    YHandle p = YHandle();
    p.do_something();
} // p is deleted here

Answer 2

您的示例是安全的，因为如果 c'tor 抛出异常，则为构造失败的对象分配的内存在传递异​​常之前被释放。当异常退出f 范围时，堆栈被展开。

如果将一个半构造并随后具有其成员和基数的对象返回到调用范围，则该范围将无法确定如何正确释放该内存，因此幸好这还没有完成。

如果在同一个函数中在堆上构造其他对象，则应用通常的规则。原则上，这里不需要特殊情况的 c'tor 调用，只需假设抛出的语句是常规函数调用即可。

Answer 3

如果抛出可能导致泄漏，那么删除分配是你的责任

您可以像这样滚动异常：

void f()
{
  X x;             //← if X::X() throws, the memory for x itself will not leak
  Y* p;
  try{  
    p = new Y();  //← if Y::Y() throws, the memory for *p itself will not leak
  } catch(exception &e){
    ///clean what you need

    throw e;
  }
}