在没有返回值优化的情况下将两个对象添加到一起时会创建多少个临时对象？

Question

I decided to ask this question after reading items 20 and 22 of the book "More Effective C++" by Scott Meyers.

Let's say you wrote a class to represent rational numbers:

class Rational
{
public:
    Rational(int numerator = 0, int denominator = 1);

    int numerator() const;
    int denominator() const;

    Rational& operator+=(const Rational& rhs); // Does not create any temporary objects
    ...
};

Now let's say that you decided to implement operator+ using operator+= :

const Rational operator+(const Rational& lhs, const Rational& rhs)
{
    return Rational(lhs) += rhs;
}

My question is: if the return value optimization were disabled, how many temporary variables would be created by operator+ ?

Rational result, a, b;
...
result = a + b;

I believe 2 temporaries are created: one when Rational(lhs) is executed inside the body of operator+ , and another when the value returned by operator+ is created by copying the first temporary.

My confusion arose when Scott presented this operation:

Rational result, a, b, c, d;
...
result = a + b + c + d;

And wrote: "Probably uses 3 temporary objects, one for each call to operator+ ". I believe that if the return value optimization were disabled, the operation above would use 6 temporary objects (2 for each call to operator+ ), while if it were enabled, the operation above would use no temporaries at all. How did Scott arrive at his result? I think the only way to do so would be to partially apply the return value optimization .

Answer 1

I think you're just considering too much, especially with the details of optimization.

For result = a + b + c + d; , the author just want to state that 3 temporaries will be created, the 1st one is for the result of a + b , then 2nd one is for the result of temporary#1 + c , the 3rd one is for temporary#2 + d and then it's assigned to result . After that, 3 temporaries are destroyed. All the temporaries are only used as the intermediate results.

On the other hand, some idioms such like expression templates could make it possible to get the final result directly with elimination of temporaries.

Answer 2

Compiler may detect accumulation and apply optimizations but generally shifting and reducing an expression from left to right is somehow tricky as it may be hit by an expression of style a + b * c * d

It is more cautious to take approach of form:

a + (b + (c + d))

which will not consume a variable before it might be required by an operator with higher priority. But evaluating it requires temporaries.

Answer 3

No variables are created by the compiler. Because variables are those appearing in the source code, and variables don't exist at execution time , or in the executable (they might become memory locations, or be "ignored").

Read about the as-if rule . Compilers are often optimizing .

See CppCon 2017 Matt Godbolt “What Has My Compiler Done for Me Lately? Unbolting the Compiler's Lid” talk .

Answer 4

In the expression a+b+c+d 6 temporaries will be created and destroyed, this is mandatory (with and without RVO). You can check it here .

Inside operator + definition, in the expression Rational(lhs)+=a , the prvalue Rational(lhs) will be bound to the implied object parameter of operator+= which is authorized according to this very specific rule [over.match.func]/5.1 (refered in [expr.call]/4 )

even if the implicit object parameter is not const-qualified, an rvalue can be bound to the parameter as long as in all other respects the argument can be converted to the type of the implicit object parameter.

Then to bind a prvalue to a reference, temporary materialization must occurs [class.temporary]/2.1

Temporary objects are materialized [...]:

• when binding a reference to a prvalue

So a temporary is created during the excution of each operator + call.

Then the expression Rational(lhs)+=a which once is returned can conceptualy seen as Rational(Rational(lhs)+=a) is a prvalue (a prvalue is an expression whose evaluation initializes an object - phi:an object in power) which is then bound to the first argument of the 2 subsequent calls to operator + . The cited rule [class.temporary]/2.1 applies twice again and will create 2 temporaries:

1. One for materializing the result of a+b ,
2. the other for materializing the result of (a+b)+c

So at this point 4 temporaries have been created. Then, the third call to operator+ creates the 5th temporary inside the function body

Finaly the result of the last call to operator + is a discarded value expression . This last rule of the standard applies [class.temporary]/2.6:

Temporary objects are materialized [...]:

• when a prvalue appears as a discarded-value expression.

Which produces the 6th temporaries.

Without RVO the return value is directly materialized, which makes temporary materialization of the return prvalues not necessary anymore. This is why GCC produces the exact same assembly with and without -fno-elide-constructors compiler option.

In order to avoid temporary materialization, you could define operator + :

const Rational operator+(Rational lhs, const Rational& rhs)
{
    return lhs += rhs;
}

With such a definition, the prvalue a+b and (a+b)+c would be directly used to initialize to first parameter of operator + which would save you from the materialization of 2 temporaries. See the assembly here .