Why is RVO disallowed when returning a parameter?

by

Imagine no_rvo is defined in a different file than main so that when compiling main the compiler will only see the declaration

X no_rvo(X x);

and will have no idea whether the object of type X returned has any relation to the argument. From what it knows at that point, the implementation of no_rvo could as well be

X no_rvo(X x) { X other; return other; }

So when it e.g. compiles the line

X const& x = no_rvo(X());

it will do the following, when maximally optimizing.

  • Generate the temporary X to be passed to no_rvo as argument
  • call no_rvo, and bind its return value to x
  • destruct the temporary object it passed to no_rvo.

Now if the return value from no_rvo would be the same object as the object passed to it, then destruction of the temporary object would mean destruction of the returned object. But that would be wrong because the returned object is bound to a reference, therefore extending its lifetime beyond that statement. However simply not destructing the argument is also no solution because that would be wrong if the definition of no_rvo is the alternative implementation I’ve shown above. So if the function is allowed to reuse an argument as return value, there can arise situations where the compiler could not determine the correct behaviour.

Note that with common implementations, the compiler would not be able to optimize that away anyways, therefore it is not such a big loss that it is not formally allowed. Also note that the compiler is allowed to optimize the copy away anyway if it can prove that this doesn’t lead to a change in observable behaviour (the so-called as-if rule).

More Related Contents:

  1. What are copy elision and return value optimization?
  2. c++11 Return value optimization or move? [duplicate]
  3. How does guaranteed copy elision work?
  4. Why does std::move prevent RVO (return value optimization)?
  5. Does returning a local variable return a copy and destroy the original(nrvo)?
  6. What is copy elision and how does it optimize the copy-and-swap idiom?
  7. Understanding return value optimization and returning temporaries – C++
  8. Why are by-value parameters excluded from NRVO?
  9. Does the behavior of guaranteed copy elision depend on existence of user-defined copy constructor?
  10. How to enforce copy elision, why it won’t work with deleted copy constructor?
  11. In C++, is it still bad practice to return a vector from a function?
  12. Move or Named Return Value Optimization (NRVO)?
  13. Why isn’t RVO applied to base class subobject initialization?
  14. Me not understanding do while loops [closed]
  15. Error: ‘pow’ was not declared in this scope
  16. Dijkstra Program
  17. Performance of built-in types : char vs short vs int vs. float vs. double
  18. Using char* as a key in std::map
  19. How to install the Raspberry Pi cross compiler on my Linux host machine?
  20. What are the differences between -std=c++11 and -std=gnu++11?
  21. Using bitwise operators for Booleans in C++
  22. Is C++11’s long long really at least 64 bits?
  23. Paint a rect on qglwidget at specifit times
  24. Comparison of double, long double, float and float128?
  25. What is the right approach when using STL container for median calculation?
  26. printf rounding behavior for doubles
  27. can void* be used to store function pointers? [duplicate]
  28. Understanding -Weffc++
  29. Advantages of using initializer list? [duplicate]
  30. Is lambdification of a concept an improvement or bad practice?

Leave a Comment