15

I thought references only extend the lifetime of temporaries to the lifetime of the reference itself, but the output of the following snippet seems contradictory:

#include <iostream>

struct X{ ~X(){ std::cout << "Goodbye, cruel world!\n"; } };

X const& f(X const& x = X()){
  std::cout << "Inside f()\n";
  return x;
}

void g(X const& x){
  std::cout << "Inside g()\n";
}

int main(){
  g(f());
}

Live example. Output:

Inside f()
Inside g()
Goodbye, cruel world!

So it seems the temporary is destroyed after g() is called... what gives?

Xeo
  • 129,499
  • 52
  • 291
  • 397

3 Answers3

20

The standard handles this in a special case in §12.2 [class.temporary]:

p4 There are two contexts in which temporaries are destroyed at a different point than the end of the full-expression. [...]

p5 The second context is when a reference is bound to a temporary. The temporary to which the reference is bound or the temporary that is the complete object of a subobject to which the reference is bound persists for the lifetime of the reference except:

  • A temporary bound to a reference parameter in a function call (5.2.2) persists until the completion of the full-expression containing the call.

The standard also has a handy note on full-expressions and the evaluation of their subexpressions with regards to default parameters in §1.9 [intro.execution] p11:

[ Note: The evaluation of a full-expression can include the evaluation of subexpressions that are not lexically part of the full-expression. For example, subexpressions involved in evaluating default arguments (8.3.6) are considered to be created in the expression that calls the function, not the expression that defines the default argument. —end note ]

Community
  • 1
  • 1
Xeo
  • 129,499
  • 52
  • 291
  • 397
1

Interesting, +1. (I do not mean to compete with your nice self answer here). Just a side note for anyone interested. If you want a similar effect but allowing non-const you could use move semantics:

#include <iostream>

struct X{
   ~X(){ std::cout << "Goodbye, cruel world!\n"; }
   X(X && x){  std::cout << "moved "; }
   X(){}
};

X  f(X x = X()){
  std::cout << "Inside f()\n";
  return x;
}

void g(X x){
  std::cout << "Inside g()\n";
}

int main(){
   g(f());
}

gives 

Inside f()
moved Inside g()
Goodbye, cruel world!
Goodbye, cruel world!
Johan Lundberg
  • 26,184
  • 12
  • 71
  • 97
  • You can also just use `X&&` and return `std::move(x)`. :) – Xeo Sep 23 '12 at 18:38
  • 1
    @Xeo "return std::move(x)" should be avoided in this case, see more details eg at https://stackoverflow.com/questions/14856344/when-should-stdmove-be-used-on-a-function-return-value – Giovanni Funchal Jul 24 '17 at 11:23
0

So it seems the temporary is destroyed after g() is called.

That's true because the lifetime of the temporary starts once f() is called and ends once g() is exited. That's because:

A temporary bound to a reference parameter in a function call (5.2.2) persists until the completion of the full-expression containing the call.

The full-expression here is g(f()) not f() because your f() function is actually looks like this

void g(X const& x){
  std::cout << "Inside g()\n";
}

X const& f(X const& x){
  std::cout << "Inside f()\n";
  return x;
}

g(f( X() ));
mada
  • 1,646
  • 1
  • 15