Why lifetime of temporary doesn’t extend till lifetime of enclosing object?

by

The standard considers two circumstances under which the lifetime of a temporary is extended:

§12.2/4 There are two contexts in which temporaries are destroyed at a different point than the end of the fullexpression. The first context is when an expression appears as an initializer for a declarator defining an object. In that context, the temporary that holds the result of the expression shall persist until the object’s initialization is complete. […]

§12.2/5 The second context is when a reference is bound to a temporary. […]

None of those two allow you to extend the lifetime of the temporary by a later binding of the reference to another const reference. But ignore the standarese and think of what is going on:

Temporaries are created in the stack. Well, technically, the calling convention might mean that a returned value (temporary) that fits in the registers might not even be created in the stack, but bear with me. When you bind a constant reference to a temporary the compiler semantically creates a hidden named variable (that is why the copy constructor needs to be accessible, even if it is not called) and binds the reference to that variable. Whether the copy is actually made or elided is a detail: what we have is an unnamed local variable and a reference to it.

If the standard allowed your use case, then it would mean that the lifetime of the temporary would have to be extended all the way until the last reference to that variable. Now consider this simple extension of your example:

B* f() {
   B * bp = new B(A());
   return b;
}
void test() {
   B* p = f();
   delete p;
}

Now the problem is that the temporary (lets call it _T) is bound in f(), it behaves like a local variable there. The reference is bound inside *bp. Now that object’s lifetime extends beyond the function that created the temporary, but because _T was not dynamically allocated that is impossible.

You can try and reason the effort that would be required to extend the lifetime of the temporary in this example, and the answer is that it cannot be done without some form of GC.

More Related Contents:

  1. How come a non-const reference cannot bind to a temporary object?
  2. Does a const reference class member prolong the life of a temporary?
  3. Lifetime of temporaries
  4. constant references with typedef and templates in c++
  5. Disallowing creation of the temporary objects
  6. Why does calling std::string.c_str() on a function that returns a string not work?
  7. Why is taking the address of a temporary illegal?
  8. prolonging the lifetime of temporaries
  9. Is it safe to make a const reference member to a temporary variable?
  10. Using paragraphs 8.5.3p4 and p5 in the C++11 Standard, how do I prove that the snippet below doesn’t compile?
  11. What is meant by Resource Acquisition is Initialization (RAII)?
  12. How do I terminate a thread in C++11?
  13. Defining static members in C++
  14. On which platforms does integer divide by zero trigger a floating point exception?
  15. Order of calling constructors/destructors in inheritance
  16. How to specialize std::hash::operator() for user-defined type in unordered containers?
  17. WINMAIN and main() in C++ (Extended)
  18. How many levels of pointers can we have?
  19. c++ custom compare function for std::sort()
  20. Why floating point value such as 3.14 are considered as double by default in MSVC?
  21. openCV program compile error “libopencv_core.so.2.4: cannot open shared object file: No such file or directory” in ubuntu 12.04
  22. g++ does not show a ‘unused’ warning
  23. Cleaning up an STL list/vector of pointers
  24. Intercept windows open file
  25. What happens when you call data() on a std::vector?
  26. Broken c++ std libraries on macOS High Sierra 10.13
  27. Calculating the info-hash of a torrent file
  28. How to calculate the angle from rotation matrix
  29. Can we apply content not explicitly cited from the normative references to the C++ standard?
  30. Output aligned columns

Leave a Comment