Resource from the book:
Dov Bulka & David Mayhew <Efficient C++--- Performance programming Techiques>
Anytime you can skip the creation and destruction of an object, you are looking at a performance gain. We will discuss an optimization often performed by compilers to speed? up your source code by transforming it and eliminating object creation. This optimization is referred to as the Return Value Optimization(RVO). Prior to delving into the RVO we need to understand how return-by-value works. We will walk through it with a simple example.
The Mechanics of Return-by-Value
The Complex class implements a representation for complex numbers:
?1
class
?Complex
?2
{
?3
???
//
?Complex?addition?operator
?4
???
friend?Complex?
operator
?
+
(
const
?Complex
&
,?
const
?Complex
&
);
?5
public
:
?6
???
//
?default?constructor
?7
???
//
?Value?defaults?to?0?unless?otherwise?specified
?8
???
Complex(
double
?r?
=
?
0.0
,?
double
?i?
=
?
0.0
):real(r),?imag(i)?
{?}
?9
10
???
//
?copy?constructor
11
???
Complex(
const
?Complex
&
?c):real(c.real),?imag(c.imag)?
{?}
12
13
???
//
?Assignment?operator
14
???
Complex
&
?
operator
?
=
(
const
?Complex
&
?c);
15
16
???
~
Complex()?
{?}
17
private
:
18
???
double
?real;
19
}
;
The addition operator returns a Complex object by value, as in:
1
Complex?
operator
?
+
(
const
?Complex
&
?a,?
const
?Complex
&
?b)
2
{
3
????Complex?retVal;
4
????retVal.real?
=
?a.real?
+
?b.real;
5
????retVal.imag?
=
?a.imag?
+
?b.imag;
6
????
return
?retVal;
7
}
Suppose c1, c2, and c3 are Complex and we excute
c3 = c1 + c2;
How do we get the value of c1 + c2 into c3? One popular technique used by compilers is to create a temporary __result object and pass it into Complex::operator +() as a third argument. It is passed by referece. So the compiler rewrites
1
Complex
&
?Complex::
operator
?
+
(
const
?Complex
&
?c1,?
const
?Complex
&
?c2)
2
{
3
??
4
}
into a slightly different function:
1
void
?Complex_Add(
const
?Complex
&
?__result,?
const
?Complex
&
?c1,?
const
?Complex
&
?c2)
2
{
3
???
4
}
Now the original source statement
c3 = c1 + c2;
is transformed into(pseudocode):
1
struct
?Complex?__tempResult;?
//
?Storage.?No?constructor?here.
2
Complex_Add(__tempResult,?c1,?c2);?
//
?All?argument?passed?by?reference.
3
c3?
=
?__tempResult;?
//
?Feed?result?back?into?left-hand-side.
This return-by-value implementation opens up an optimization opportunity by eliminating the local object RetVal(inside operator +()) and computing the return value directly into the __tempResult temporary object. This is the Return Value Optimization.