Question

This question is inspired by Using an object after it’s destructor is called

Let’s consider the following code

class B 
  {
  public:
    B() { cout << "Constructor B() " << endl; }
    ~B() { cout << "Destructor ~B() " << endl; }
  };

class A {
public:
  B ob;
  A()
      try
      { 
      throw 4;
      }
    catch(...)
      {
      cout << "Catch in A()\n";
      }

  A(int)
    {
    try
      {
      throw 4;
      }
    catch(...)
      {
      cout << "Catch in A(int)\n";
      }
    }
  };

int main()
  {
  try
  {
      A f;
  }
  catch (...)
  {
      cout << "Catch in main()\n\n";
  }
  A g(1);
  }

It’s output is

Constructor B() 
Destructor ~B() 
Catch in A()
Catch in main()

Constructor B() 
Catch in A(int)
Destructor ~B() 

In contrast to A(int), constructor A() has the initializer list try/catch syntax. Why that makes a difference on the order of the subobject destruction? Why the exception thrown in A() propagates to main()?

Answer 1

Why that makes a difference on the order of the subobject destruction?

In general, in the function catch clause of A(), you wouldn’t know which members had been successfully constructed, because the exception might have come from one of their constructors. So to remove doubt they’re destroyed first. Basically the function try/catch is “outside” the data member construction.

Why the exception thrown in A() propagates to main()?

The function catch clause can’t make the constructor succeed (because if its members weren’t constructed successfully, then the object itself hasn’t been constructed successfully). So if you don’t throw something else from it then the original exception is rethrown. That’s just how it’s defined, you can’t use a function-try clause to ignore the problem. You can use a regular try/catch inside a function to ignore a problem, then it’s up to you to decide whether or not the problem has prevented the object from being correctly constructed.