Temporaries, references and ternary operator in C++

Question

I've got the following base code:

struct X {
  X(const char* descr) {...}
  ~X() {...} // Not virtual
  virtual void foo() const {...}
};

struct Y : public X {
  Y(const char* descr) {...}
  ~Y() {...} // Not virtual
  virtual void foo() const {...}
};


const X& factory() {
    static X sampleX{"staticX"};
    static Y sampleY{"staticY"};
    return X or Y depending of the test case;
};

And 4 test cases:

Just Y = OK

const X& var = Y{"temporaryY"};
var.foo();

Result:

X::X() // base temporaryY
Y::Y() // temporaryY
Y::foo()
Y::~Y() // temporaryY
X::~X() // base temporaryY

Just X = OK

const X& var = X{"temporaryX"};
var.foo();

Result:

X::X() // temporaryX
X::foo()
X::~X() // temporaryX

Y or X via function = OK

const X& var = factory();
var.foo();

Result:

X::X() // staticX
X::X() // base staticY
Y::Y() // staticY
X::foo() or Y::foo()
Y::~Y() // staticY
X::~X() // base staticY
X::~X() // staticX

Y or X via ternary operator = WTF?!

const X& var = false ? X{"temporaryX"} : Y{"temporaryY"};
var.foo();

Result:

X::X() // base temporaryY
Y::Y() // temporaryY
Y::~Y() // temporaryY
X::~X() // base temporaryY
X::foo()
X::~X() // base temporaryY

Could someone explain me why for the seven hells:

• Destructor of Y is called before end of the scope?
• X::foo() was called instead of Y::foo()?
• Destructor of X is run twice?

Answer 1

What you're missing is that your temporary Y is getting copy-constructed-by-slice into a hidden temporary X that's bound to your const reference. That is then the final destructor you see and also explains why the Y is destructed earlier than expected. The reason this copy is made is that the "return" from the ternary operator is only one type. An X can't possibly ever be treated as a Y so X is the common type to be used, thus inducing the extra temporary X object.

Note that this is different from the "Just Y" test case, because in that instance a Y temporary is created and then immediately attempts to bind to a const X& which is allowed. In the ternary case, the operator itself induces an intermediate slice to the common object type of the operators operands, in this case X.

I believe you can avoid the temporary slice by casting to parent reference but I don't have access to a C++11 compiler to test this (in addition to the somewhat incomplete code in the question):

const X& var = false ? X{"temporaryX"} : static_cast<const X&>(Y{"temporaryY"});