I wanted to verify the if the following optimizations work as expected:
- RVO
- Named RVO
- Copy elision when passing an argument by value
So I wrote this little program:
#include <algorithm>
#include <cstddef>
#include <iostream>
#include <vector>
struct Foo {
Foo(std::size_t length, char value) : data(length, value) { }
Foo(const Foo & rhs) : data(rhs.data) { std::cout << "*** COPY ***" << std::endl; }
Foo & operator= (Foo rhs) {
std::cout << "*** ASSIGNMENT ***" << std::endl;
std::swap(data, rhs.data); // probably expensive, ignore this please
return *this;
}
~Foo() { }
std::vector<char> data;
};
Foo TestRVO() { return Foo(512, 'r'); }
Foo TestNamedRVO() { Foo result(512, 'n'); return result; }
void PassByValue(Foo inFoo) {}
int main()
{
std::cout << "\nTest RVO: " << std::endl;
Foo rvo = TestRVO();
std::cout << "\nTest named RVO: " << std::endl;
Foo named_rvo = TestNamedRVO();
std::cout << "\nTest PassByValue: " << std::endl;
Foo foo(512, 'a');
PassByValue(foo);
std::cout << "\nTest assignment: " << std::endl;
Foo f(512, 'f');
Foo g(512, 'g');
f = g;
}
And I compiled it with optimizations enabled:
$ g++ -o test -O3 main.cpp ; ./test
This is output:
Test RVO:
Test named RVO:
Test PassByValue:
*** COPY ***
Test assignment:
*** COPY ***
*** ASSIGNMENT ***
According to the output RVO and named RVO work as expected. However, copy elision is not performed for the assignment operator and when calling PassByValue
.
Is copy elision not allowed on user defined copy-constructors? (I know that RVO is explicitly allowed by the standard but I don't know about copy elision when passing by value.) Is there a way to verify copy elision without defining copy constructors?
Best Answer
The standard says (in paragraph 12.8.15):
Neither of these cases applies here, so the elision is not allowed. The first on is obvious (no return). The second is not allowed, because the object you pass in is not a temporary.
Note that your code is still fine, because you would have to create the copy anyway. To make away with that copy, you would have to use C++0x's move-semantics.