Does the C ++ standard ensure that uniform initialization eliminates security?

Question

#include <iostream> using namespace std; struct A { A() { cout << "A" << endl; } ~A() { cout << "~A" << endl; } }; A Ok() { return {}; } A NotOk() { throw "NotOk"; } struct B { A a1; A a2; }; void f(B) {} int main() { try { f({ Ok(), NotOk() }); } catch (...) {} } 

vc++ and clang output:

 A ~A 

So far, gcc outputs:

 A 

Seems like a serious GCC bug.

For reference, see GCC Error 66139 and “Serious GCC Error” by Andrzej Krzhemeyski .

I'm just curious:

Does the C ++ standard mean that uniform initialization is safe?

Answer 1

It seems so:

Curious to find in §6.6 / 2 Jump Statements [stmt.jump] all the places (N4618):

When leaving the scope (no matter how it was) objects with automatic (3.7.3) that were built in this area are destroyed in the reverse order of their construction. [Note: for temporary, see 12.2. -end note] Passing from a loop from block to back after an initialized variable with automatic storage duration includes the destruction of objects with automatic storage duration, which is in scope at the point transmitted but not at the point transferred. (See 6.7 for transmission to blocks). [Note: However, a program can be terminated (by calling std::exit() or std::abort() (18.5), for example) without destroying class objects with automatic storage time. -end note]

I think that the emphasis here is on the "(although achieved)" part. This includes an exception (but excludes things that call std::terminate ).

---

EDIT

I think the best reference is: §15.2 / 3 Constructors and destructors [except.ctor] ( emphasis ):

If the initialization or destruction of an object, except for the delegating constructor, ends with an exception, the destructor is called for each of the objects of direct subobjects , and for the full object, the subobjects of the virtual base class whose initialization is (8.6) and whose destructor has not yet begun, except in the case destruction members of the union class option are not destroyed. Subobjects are destroyed in the reverse order of completion of their construction. such destruction is sequenced before the input of the function-try-block handler of the constructor or destructor, if any.

This will include aggregate initialization (which I learned today can be called non-empty initialization)

... and for objects with constructors we can give article 12.6.2 / 12 [class.base.init] ( emphasis ):

In a constructor without delegation, a destructor for each potentially constructed subobject of a class type is potentially called (12.4). [Note: This condition ensures that destructors can be called for fully constructed subobjects if an exception is thrown (15.2). -end note]