临时生命周期扩展和隐式转换为 const 引用

Question

Normally, binding a temporary to a local const& extends the lifetime of the temporary until the end of the scope of the reference:

struct Foo { void DoSomething() const; };
Foo Make();

const Foo& foo = Make(); // compiles
foo.DoSomething(); // ok, lifetime of foo was extended

But when an implicit conversion is involved, this is no longer the case:

struct Foo { void DoSomething(); };
struct Bar { operator const Foo&() const; };
Bar Make();

const Foo& foo = Make(); // compiles calling the implicit conversion operator
foo.DoSomething(); // not ok, temporary Bar has been destroyed

Is this actually what is specified in the C++ standard? Is this intended? Is it legal to declare such an implicit conversion operators to a const& ? (Another question is how that conversion operator should be implemented. In this case, it would need to involve a reinterpret_cast relying on Foo and Bar having a compatible binary representation, which is probably undefined behavior. In C++20, probably a bit_cast might be used? But suppose Foo derived from Bar , a static_cast could be used, removing the undefined behavior and the situation does not change).

Answer 1

Is this intended?

Yes. The lifetime of temporary Bar won't be extended to the lifetime of foo .

In general, the lifetime of a temporary cannot be further extended by "passing it on": a second reference, initialized from the reference to which the temporary was bound, does not affect its lifetime.

That means, the lifetime of temporary bound to reference directly would be extended. In this case, the temporary Bar returned by Make() isn't bound to foo directly.