派生类构造函数中的异常

Question

我在处理派生类中的构造函数异常时遇到了一些问题。当派生类构造函数抛出错误，但父类已经分配了一些对象。会调用父类的析构函数吗？

例子：

class A
{
  A() { /* Allocate some stuff */ };

  virtual ~A() { /* Deallocate stuff */ };
};

class B : public A
{
  B() 
  { 
    /* Do some allocations */
    ...

    /* Something bad happened here */
    if (somethingBadHappened) 
    {
      /* Deallocate B Stuff */
      ...

      /* Throws the error */
      throw Error; /* Will A destructor be called? I know B destructor won't */
    };

  };

  ~B() { /* Deallocate B Stuff */ };
}

我想知道执行以下操作是否是个好主意：

B()
{ 
  /* Do some allocations */
  ...

  /* Something bad happened here */
  if (somethingBadHappened) 
  {
    /* Deallocate B Stuff */
    this->~B();

    /* Throws the error */
    throw Error; /* Will A destructor be called? I know B destructor won't */
  };
};

如果不是，那么做这些事情的好方法是什么？

Answer 1

异常将导致堆栈展开到正确捕获异常的点。这意味着在抛出异常之前的范围内创建的任何对象都将被销毁，包括本例中的基类对象。

试试这个：

#include <iostream>

class A
{
public:
  A() { std::cout << "A::A()\n";}
  ~A() {std::cout << "A::~A()\n";}
};

class B : public A
{
public:
   B()
   {
      std::cout << "B::B()\n";
      throw 'c';
   }

   // note: a popular point of confusion -- 
   //   in this example, this object's destructor
   //   WILL NOT BE CALLED!
   ~B()
   {
      std::cout << "B::~B()\n";
   }
};


int main()
{
   try
   {
      B b;
   }

   catch(...)
   {
      std::cout << "Fin\n";
   }
   return 0;
}

输出应该是：（注意 B::~B() 没有被调用）

A::A()
B::B()
A::~A()
Fin

只要您不尝试释放尚未分配的资源，就可以安全地按照您在问题中显示的方式手动调用析构函数。最好将这些资源包装在某种类型的 RAII 容器中（std::auto_ptr、boost::shared_ptr 等）以避免调用析构函数的必要性。

Mooing Duck 很好地说明了在构造函数中抛出异常时堆栈展开是如何工作的：

Answer 2

一直没有想到这一点，但也许可以考虑在 try/catch 块中创建对象。如果构造函数抛出异常，delete 对象，如果它是使用new 创建的。

try
{
    B* b = new B();
}
catch
{
    delete b;
    //log error
}

如果不使用new为b分配内存，则不需要在catch块中调用delete。

确保您的 B 析构函数不会对从未创建的对象调用 delete。我建议在执行任何可能导致异常的操作之前，在构造函数中将所有指向对象的指针设置为 0。这样，如果调用了析构函数，deleteing 他们是安全的。

Answer 3

您在问题的第二部分中尝试编写干净的构造函数B::B() 的失败尝试突出了在一个类中承担过多责任的设计的尴尬。如果您只使用单一职责组件，您通常可以完全不编写任何显式错误检查，而让异常处理机制以递归方式完成其工作。

考虑一下：

B::B()
{
  try { this->p1 = get_dangerous_pointer(); }
  catch(...) { throw; } // OK

  try { this->p2 = suicidal_function(); }
  catch(...) {
    clean_up(p1);
    throw;
  }

  try { this->p3 = get_monstrous_amounts_of_memory(); }
  catch(...)
  {
    clean_up(p2);
    clean_up(p1);
    throw;
  }
}

如您所见，为一个只有三个不同职责的类编写正确的构造函数是一场维护噩梦。

正确的解决方案是让每个资源都归一个包装类所有，该包装类的唯一职责就是拥有该资源，并且即使面对最异常的异常，也会自动进行清理。

还请注意，在从任何构造函数中调用成员函数时，您必须非常小心。一个对象的生命周期直到构造函数完成后才开始，所以当你在构造函数中时，你正在处理一个“正在构造的对象”——有点像心脏直视手术……对你自己。特别是，你不能调用析构函数，因为你只能销毁完整的对象。

Answer 4

最好的办法是在构造中捕获异常，然后将对象置于会产生错误的状态（例如对象读取文件，在构造函数中打开文件失败，然后读取将不起作用）。

只要保持对象一致即可。