Destruction of return value on destructor exception

Question

I have the following code:

#include <stdexcept>
#include <iostream>

struct ok {
    int _n;
    ok(int n) : _n(n) { std::cerr << "OK" << n << " born" << std::endl; }
    ~ok() {  std::cerr << "OK" << _n << " gone" << std::endl; }
};

struct problematic {
    ~problematic() noexcept(false) { throw std::logic_error("d-tor exception"); }
};

ok boo() {
    ok ok1{1};
    problematic p;
    ok ok2{2};
    return ok{3}; // Only constructor is called...
}

int main(int argc, char **argv) {
    try {boo();} catch(...) {}
}

I see that he destructor of ok{3} is not called, the output is:

 OK1 born
 OK2 born
 OK3 born
 OK2 gone
 OK1 gone

Is it the expected behavior for C++14?

EDITs:

Compiling with gcc 6.3

@Someprogrammerdude What do you expect to not happen? Objects are expected to not be destructed, now? — curiousguy, Nov 06 '18 at 07:36
I think you should add the `language-laywer` tag to the question, and edit it to ask how it's defined in the standard. And of course, include the exact compiler (and version) you're using. Possibly add how you build (with optimizations flags etc.). — Some programmer dude, Nov 06 '18 at 07:39
VS 15.9.0: `OK2 gone OK1 gone OK3 gone`, GCC 7.1.0 and Clang 7.0.0: `OK2 gone OK1 gone`. — Evg, Nov 06 '18 at 07:48
"If an exception is thrown from a destructor of a local variable or of a temporary used in a return statement, the destructor for the object returned from the function is also invoked. **(since C++14)**" https://en.cppreference.com/w/cpp/language/throw — Mat, Nov 06 '18 at 07:49
This is [defect #2176](http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#2176). The fix may not have made it into 6.3. — molbdnilo, Nov 06 '18 at 08:10

P.W · Accepted Answer · 2018-11-06T08:53:22.687

As per the standard this behavior is wrong and this has already been mentioned in the comments section of the question. This is stated in the section on Exception handling.

As per the defect reports at open-std.org, they have been aware that implementations (GCC and Clang) were wrong about this as early as 2015-09-28. But the proposed resolution was only in February, 2016 and the compilers (GCC and Clang) have not yet included this fix.

Proposed resolution (February, 2016):

Change 18.2 [except.ctor] paragraph 2 as follows:
The destructor is invoked for each automatic object of class type constructed, but not yet destroyed, since the try block was entered. If an exception is thrown during the destruction of temporaries or local variables for a return statement (9.6.3 [stmt.return]), the destructor for the returned object (if any) is also invoked. The objects are destroyed in the reverse order of the completion of their construction. [Example:
  struct A { };

  struct Y { ~Y() noexcept(false) { throw 0; } };

  A f() {
    try {
      A a;
      Y y;
      A b;
      return {};   // #1
    } catch (...) {
    }
    return {};     // #2
  }
At #1, the returned object of type A is constructed. Then, the local variable b is destroyed (9.6 [stmt.jump]). Next, the local variable y is destroyed, causing stack unwinding, resulting in the destruction of the returned object, followed by the destruction of the local variable a. Finally, the returned object is constructed again at #2. —end example]

There have been bugs filed against this issue both in GCC and Clang.

The comments on the GCC bug report indicate that it is clearly a bug.

Jonathan Wakely comments:

It's now 2013 so the sensible thing to do is not return by value if your destructor can throw.

And another user:

Yes, I noticed, and Clang has also had a bug filed against them which has languished for years. Nevertheless, the behavior is wrong.

Destruction of return value on destructor exception

1 Answers1