c ++中的临时对象如何影响效率？

Question

I have read an article on CodeProject http://www.codeproject.com/Tips/103648/C-Tip-How-to-eliminate-Temporary-Objects .

Complex y,z;
Complex x=y+z; /* initialization instead of assignment */

I confused that why the second statment does not create a temporary object? how does the compiler works?

Answer 1

There is a rule in C++, which allows the compiler to ellide temporaries, if they are directly used for initialising.
Anyway, using its leeway, the compiler could optimize the example without this rule anyway, which has the same effect.

12.8 Copying and moving class objects §32

When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the copy/move constructor and/or destructor for the object have side effects. In such cases, the implementation treats the source and target of the omitted copy/move operation as simply two different ways of referring to the same object, and the destruction of that object occurs at the later of the times when the two objects would have been destroyed without the optimization.123 This elision of copy/move operations, called copy elision, is permitted in the following circumstances (which may be combined to eliminate multiple copies):
— in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object (other than a function or catch-clause parameter) with the same cvunqualified type as the function return type, the copy/move operation can be omitted by constructing the automatic object directly into the function's return value
— in a throw-expression, when the operand is the name of a non-volatile automatic object (other than a function or catch-clause parameter) whose scope does not extend beyond the end of the innermost enclosing try-block (if there is one), the copy/move operation from the operand to the exception object (15.1) can be omitted by constructing the automatic object directly into the exception object
— when a temporary class object that has not been bound to a reference (12.2) would be copied/moved to a class object with the same cv-unqualified type, the copy/move operation can be omitted by constructing the temporary object directly into the target of the omitted copy/move
— when the exception-declaration of an exception handler (Clause 15) declares an object of the same type (except for cv-qualification) as the exception object (15.1), the copy/move operation can be omitted by treating the exception-declaration as an alias for the exception object if the meaning of the program will be unchanged except for the execution of constructors and destructors for the object declared by the exception-declaration.

Answer 2

In the first example in the link that you provide, the assignment operator is called:

Complex x, y, z;
x=y+z;

In the second example in the link that you provide, the constructor is called:

Complex y,z;
Complex x=y+z;

But in both cases, a temporary object (containing the value of x+y ) is created.

So I seriously doubt the correctness of this link.

I would be happy to read any answer to your question that explains otherwise...

---

Temporary objects that we can avoid are usually the ones passed to a function or returned from a function by value instead of by reference.

For example, in Complex::operator+= below, one temporary object is created on the stack when the function is called, and another temporary object is created on the stack when the function returns:

Complex Complex::operator+=(Complex num)
{
    this->real += num.real;
    this->imag += num.imag;
    return *this;
}

void func()
{
    Complex a(1,2);
    Complex b(3,4);
    a += b;
    ...
}

In order to eliminate both temporary objects, you can simply pass and return by reference:

Complex& Complex::operator+=(Complex& num)
{
    ...
}

Please note that passing an argument by reference is feasible in member functions as well as in global functions, but returning an argument by reference is feasible only in member functions (unless you return a global variable from a global function, but that is rather pointless in most cases).