I have tested your code. You are correct. In Visual Studio 2008, the
1. call constructor with 10;
2. call constructor with 20;
3. call constructor with 30;
4. call destructor with 10;
5. call destructor with 20.
On Dec 18, 2:57 pm, George <Geo...@discussions.microsoft.com> wrote:
Hi Alex,
I lost your points in your reply. You gave us two choices,
1. const X& result = X(1) + X(2);
2. X result = X(1) + X(2);
Which one do you think is optimized? why?
To me, as of now, both look the same from optimization point of view
i.e. for compilers that support RVO (and are capable of copy
construction elision - with VS2005, I don't get any copy constructor
calls even with optimizations disabled - its pretty good! semantically
there would be 2 - one for the return by value and while copy
construction of ref with that returned value). Here is the code that I
tested and it does not call the copy constructor in any of the cases
(uncomment to see):
#include<iostream>
struct A
{
int i;
A(int i_):i(i_){std::cout << "constructor\n";}
A(const A& rhs) : i(rhs.i){std::cout << "copy constructor\n";}
A& operator=(const A& rhs){i=rhs.i;std::cout << "assignment operator
\n";}
A operator+(const A& rhs)
{
return A(i+rhs.i);
}
~A(){std::cout << "destructor\n";}
};
int main()
{
const A ref = A(10) + A(20);
//const A& ref = A(10) + A(20);
//A ref = A(10) + A(20);
std::cout << ref.i << std::endl;
return 0;
}