Why is it illegal to take the address of an rvalue temporary?

by

Actually, in the original language design it was allowed to take the address of a temporary. As you have noticed correctly, there is no technical reason for not allowing this, and MSVC still allows it today through a non-standard language extension.

The reason why C++ made it illegal is that binding references to temporaries clashes with another C++ language feature that was inherited from C: Implicit type conversion.
Consider:

void CalculateStuff(long& out_param) {
    long result;
    // [...] complicated calculations
    out_param = result;
}

int stuff;
CalculateStuff(stuff);  //< this won't compile in ISO C++

CalculateStuff() is supposed to return its result via the output parameter. But what really happens is this: The function accepts a long& but is given an argument of type int. Through C’s implicit type conversion, that int is now implicitly converted to a variable of type long, creating an unnamed temporary in the process.
So instead of the variable stuff, the function really operates on an unnamed temporary, and all side-effects applied by that function will be lost once that temporary is destroyed. The value of the variable stuff never changes.

References were introduced to C++ to allow operator overloading, because from the caller’s point of view, they are syntactically identical to by-value calls (as opposed to pointer calls, which require an explicit & on the caller’s side). Unfortunately it is exactly that syntactical equivalence that leads to troubles when combined with C’s implicit type conversion.

Since Stroustrup wanted to keep both features (references and C-compatibility), he introduced the rule we all know today: Unnamed temporaries only bind to const references. With that additional rule, the above sample no longer compiles. Since the problem only occurs when the function applies side-effects to a reference parameter, it is still safe to bind unnamed temporaries to const references, which is therefore still allowed.

This whole story is also described in Chapter 3.7 of Design and Evolution of C++:

The reason to allow references to be initialized by non-lvalues was to allow the distinction between call-by-value and call-by-reference to be a detail specified by the called function and of no interest to the caller. For const references, this is possible; for non-const references it is not. For Release 2.0 the definition of C++ was changed to reflect this.

I also vaguely remember reading in a paper who first discovered this behavior, but I can’t remember right now. Maybe someone can help me out?

More Related Contents:

  1. how to control one program from other
  2. Undefined reference to static class member
  3. Is short-circuiting logical operators mandated? And evaluation order?
  4. Does C++ support Variable Length Arrays?
  5. How can I create directory tree in C++/Linux?
  6. How do I explicitly instantiate a template function?
  7. How to check whether operator== exists?
  8. What are the differences between .so and .dylib on macOS?
  9. understanding of pthread_cond_wait() and pthread_cond_signal()
  10. Stack-buffer based STL allocator?
  11. Sorting two corresponding arrays [duplicate]
  12. How to mix C++ and C correctly
  13. Link errors using members in C++17
  14. Is std::abs(0u) ill-formed?
  15. What are uses of the C++ construct “placement new”?
  16. What exactly is streambuf? How do I use it?
  17. Recommended values for OpenCV detectMultiScale() parameters
  18. Practical Uses for the “Curiously Recurring Template Pattern”
  19. Read file names from a directory
  20. Should I unify two similar kernels with an ‘if’ statement, risking performance loss?
  21. Visual studio 2015 run-time dependencies or how to get rid of Universal CRT?
  22. How to create a template function within a class? (C++)
  23. C++ Thread Pool [closed]
  24. Why “Foo f(Bar());” can be a declaration of a function that takes type Bar and returns type Foo? [duplicate]
  25. Why does the compiler choose bool over string for implicit typecast of L””?
  26. In lambda functions syntax, what purpose does a ‘capture list’ serve?
  27. Unary plus (+) against literal string
  28. c++11 std::async doesn’t work in mingw
  29. How can I use C++ with Objective-C in XCode
  30. C++ GDB Python Pretty Printing Tutorial?

Leave a Comment