Return value optimization
From Wikipedia, the free encyclopedia
Return value optimization , or simply RVO , is a C++ -specific compiler optimization technique that involves eliminating the temporary object created to hold a function 's return value.[ 1] It is particularly notable for being allowed to change the observable behaviour of the resulting program .[ 2]
Contents[hide ] |
[edit ] Summary
In general, the C++ standard allows a compiler to perform any optimization, as long as the resulting executable exhibits the same observable behaviour as if all the requirements of the standard has been fulfilled. This is commonly referred to as the as-if rule .[ 3] The term return value optimization refers to a special clause in the C++ standard that allows an implementation to omit a copy operation resulting from a return statement , even if the copy constructor has side effects ,[ 4] something that is not permitted by the as-if rule alone.[ 3]
The following example demonstrates a scenario where the implementation may eliminate one or both of the copies being made, even if the copy constructor has a visible side effect (printing text).[ 4] The first copy that may be eliminated is the one where first
is copied into the function f
's return value . The second copy that may be eliminated is the copy of the temporary object returned by f
to second
.
Depending on the compiler , and the compiler's settings, the resulting program may display any of the following outputs:
Hello World!
Hello World!
Hello World!
<nothing>
Background
Returning an object of builtin type from a function usually carries little to no overhead, since the object typically fits in a CPU register . Returning a larger object of class type may require more expensive copying from one memory location to another. To achieve this, an implementation may create a hidden object in the caller's stack frame , and pass the address of this object to the function. The function's return value is then copied into the hidden object.[ 5] Thus, code such as this:
May generate code equivalent to this:
which causes the Data
object to be copied twice.
In the early stages of the evolution of C++ , the language's inability to efficiently return an object of class type from a function was considered a weakness.[ 6] Around 1991, Walter Bright invented a technique to minimize copying; effectively replacing the hidden object and the named object inside the function with the object used to hold the result:[ 7]
Bright implemented this optimization in his Zortech C++ compiler.[ 6] This particular technique was later coined "Named return value optimization", referring to the fact that the copying of a named object is elided.[ 7]
[edit ] Compiler support
Return value optimization is supported on most compilers,[ 1] including Microsoft Visual C++ ,[ 8] g++ ,[ 9] and the Intel C++ Compiler .
However, there may be circumstances where the compiler is unable to perform the optimization. One common case is when a function may return different named objects depending on the path of execution: [ 8] [ 10] [ 5]
[edit ] Other forms of copy elision
Apart from the elision of the copy operation in a return statement, section 12.8, paragraph 15 of the C++ standard lists another case where copy elision is allowed, namely when a temporary object of class type is copied to an object of the same type.[ 4] This is also a very widely implemented optimization. As a result, copy-initialization is usually equivalent to direct-initialization in terms of performance, but not in semantics; copy-initialization still requires an accessible copy constructor .[ 11] The optimization can not be applied to a temporary object that has been bound to a reference. Example:
The C++ standard also mentions that a similar optimization may be applied to objects being thrown and caught ,[ 12] [ 13] but it is unclear whether the optimization applies to both the copy from the thrown object to the exception object , and the copy from the exception object to the object declared in the exception-declaration of the catch clause . It is also unclear whether this optimization only applies to temporary objects , or named objects as well.[ 14] Given the following source code:
A conforming compiler should therefore produce a program that prints "Hello World!" twice. In the upcoming C++ standard (C++0x ), the issues have been addressed, essentially allowing the same set of outputs as the first program.[ 14