In many lower-level programming languages such as C, C++, and Rust, when a function returns a value, it is usually copied or moved to the variable that receives the return value. While it's true that compilers often optimize this process, allowing the value to be written directly into the variable, this isn't guaranteed in all cases. I'm curious why functions don't simply receive a pointer to a memory space where they can write the return value directly, instead of copying it into a variable. What are the reasons behind this design choice?
5 Answers
In C++, compilers can optimize by skipping the copy step under certain conditions. If you write a class and add a print statement in the copy constructor, you may find that depending on optimization settings, the constructor may or may not run due to these optimizations. This suggests that the compiler has the flexibility to omit unnecessary operations when possible.
In summary, most compilers are smart enough to decide when copying is necessary. If you could directly write to the variable, the compiler would likely have already optimized it out. However, for instances where writing directly isn't feasible, such as conditional returns or complex types, the compiler manages the return effectively. Also, languages like C# have found ways to handle this through `out` parameters, which can be uninitialized and still be properly assigned.
Many times, return values are kept in registers, which speeds up the process significantly. If you were to pass pointers directly for returns, it could make things unnecessarily complicated, especially for operations like `x = f(x)` where you may not want to overwrite the original value immediately.
One reason for this is that not every situation uses variables in the same way. For instance, in chained operations like `int a = pow2(pow2(2), pow2(5));`, variables aren't always used directly for return values. Functions often return results that are utilized immediately, so it might not be necessary to have a separate memory address for those cases.
That's a good point! Even in those situations, there's an anonymous variable involved, so writing directly might still work.
Most common Application Binary Interfaces (ABIs) actually require that if a return value can't fit into a register, the caller creates a space for it and passes it as a pointer. In C++, from C++17 onwards, functions constructing return values in a statement should do this directly without copying. While this optimizes memory usage, the complexity of determining the appropriate memory location often complicates things.
Isn't return value optimization (RVO) guaranteed with modern compilers now?