An exception gets thrown twice from a constructor with a function-try-block

Question

Why does the following exception thrown from the constructor of class A get caught twice, first by the catch within the constructor itself and second time by the catch in th

Answer 1

It seems logical. Consider two following scenarios.

i. Try block is inside constructor's body:

  A() : i(0) {
    try
    {
       throw E("Exception thrown in A()");
    }
    catch (E& e) {
       cout << e.error << endl;
    }
    // If code reaches here,
    // it means the construction finished well
  }

ii. Try block is in initializer ctor:

  A() try : i(0) {
     throw E("Exception thrown in A()");
  }
  catch (E& e) {
     cout << e.error << endl;

     // OK, you handled the exception,
     // but wait you didn't construct the object!
  }

In the first case, after an exception, you will handle it inside the constructor and then you will construct the object properly.

In the second case, after an exception you will handle it there. BUT you didn't construct the object yet and you have no object in the caller's side. The caller should handle an un-constructed object situation.

Answer 2

You are utilizing a feature called function-try-catch. When used in a constructor, it allows catching exceptions in the initialization list (especially useful for catching exceptions in base class constructors) as well as the constructor body. But since the exception is thrown in a constructor, the class is incomplete, so the compiler automatically rethrows any caught exception. that is why you see it caught twice.

Read the following article for more details:

Constructors and Exception in C++

Answer 3

Function-try-blocks in a constructor cannot prevent exceptions. Once an exception occurs in a constructor, you have no object, and the exception must propagate. The only thing the function-try-block can do is some local clean-up.

Constructors are indeed a very special animal with regards to function-try-blocks.

Cf. C++11 15.3/14:

The currently handled exception is rethrown if control reaches the end of a handler of the function-try-block of a constructor or destructor.

---

Tl;dr: Do not use function-try-blocks, ever.