const reference to a temporary object becomes broken after function scope (life time)

by

The lifetime-extension of a temporary object can be performed only once, when the temporary object gets bound to the first reference. After that, the knowledge that the reference refers to a temporary object is gone, so further lifetime extensions are not possible.

The case that is puzzling you

A const& refnop = A(a).nothing();

is similar to this case:

A const& foo(A const& bar)
{
    return bar;
}
//...
A const& broken = foo(A());

In both cases, the temporary gets bound to the function argument (the implicit this for nothing(), bar for foo()) and gets its lifetime ‘extended’ to the lifetime of the function argument. I put ‘extended’ in quotes, because the natural lifetime of the temporary is already longer, so no actual extension takes place.

Because the lifetime extension property is non-transitive, returning a reference (that happens to refer to a temporary object) will not further extend the lifetime of the temporary object, with as result that both refnop and broken end up referring to objects that no longer exist.

More Related Contents:

  1. Why ‘&’ reference in not required in classes in C++?
  2. Returning const reference to local variable from a function
  3. C++ Return value, reference, const reference
  4. When to use references vs. pointers
  5. When should I use the new keyword in C++?
  6. What is a reference variable in C++?
  7. How to “return an object” in C++?
  8. Can we reassign the reference in C++?
  9. Is null reference possible?
  10. How does a C++ reference look, memory-wise?
  11. Scope vs. Lifetime of Variable
  12. One VS2010 bug ? Allowing binding non-const reference to rvalue WITHOUT EVEN a warning?
  13. C++11 auto: what if it gets a constant reference?
  14. how to initialize a constexpr reference
  15. Passing references to pointers in C++
  16. When is an object “out of scope”?
  17. Nested templates with dependent scope
  18. Where are temporary object stored?
  19. Should I pass an std::function by const-reference?
  20. Why do un-named C++ objects destruct before the scope block ends?
  21. What is the difference between std::reference_wrapper and a simple pointer?
  22. Is there a platform or situation where dereferencing (but not using) a null pointer to make a null reference will behave badly?
  23. Why can’t I initialize a reference in an initializer list with uniform initialization?
  24. Returning non-const reference from a const member function
  25. Why do some people prefer “T const&” over “const T&”?
  26. Modifying reference member from const member function in C++
  27. prolonging the lifetime of temporaries
  28. Why is a c++ reference considered safer than a pointer?
  29. STL map containing references does not compile
  30. Pass by pointer & Pass by reference [duplicate]

Leave a Comment