Should exceptions thrown from class member initializers call std::terminate()?

Question

Given this code:

struct A {
    A(int e) { throw e; }
};

struct B {
    A a{42}; // Same with = 42; syntax
};

int main() {
    try {
        B b;
    } catch (int const e) {
        return e;
    }
}

When compiled with GCC (versions 4.7.4, 4.8.5, 4.9.3, 5.4.0, 6.3.0):

$ g++ -std=c++11 test.cpp -o test; ./test ; echo $?
terminate called after throwing an instance of 'int'
Aborted
134

But when compiled with Clang (version 4.0.0):

$ clang++ -std=c++11 test.cpp -o test; ./test ; echo $?
42

Which behavior is correct?

Answer 1

This is a bug in GCC (Bug 80683).

If the constructor is the first op in the try/catch clause, then the compiler considered it as being outside of it although it should include it.

For example, the following works just fine:

#include <iostream>

struct A {
    A(int e) { throw e; }
};

struct B {
    A a{42}; // Same with = 42; syntax
};

int main() {
    try {
        // The following forces the compiler to put B's contructor inside the try/catch.
        std::cout << "Welcome" << std::endl; 
        B b;
    } catch (int e) {
        std::cout << "ERROR: " << e << std::endl; // This is just for debugging
    }

    return 0;
}

Running:

g++ -std=c++11 test.cpp -DNDEBUG -o test; ./test ; echo $?

Outputs:

Welcome
ERROR: 42
0

My guess is that is that due to compiler optimization, it moves the constructor to the beginning of the main function. It assumes that the struct B has no constructor, then it assumes that it would never throw an exception, thus it is safe to move it outside of the try/catch clause.

If we will change the declaration of struct B to explicitly use struct A constructor:

struct B {
    B():a(42) {}
    A a;
};

Then the result will be as expected and we will enter the try/catch, even when removing the "Welcome" printout:

ERROR: 42
0

Answer 2

Clang is correct. References about that can be found in C++ standard reference draft n4296 (emphasize mine):

15.3 Handling an exception [except.handle]

...
3 A handler is a match for an exception object of type E if
(3.1) — The handler is of type cv T or cv T& and E and T are the same type (ignoring the top-level cv-qualifiers),

Here an int is thrown, and the handler declares a const int. There is a match and the handler shall be invoked.