vector.push_back rvalue and copy-elision

Question

I push_back a temporary object into a vector like this,

vector<A> vec;
vec.push_back(A("abc"));

will the compiler apply copy-elision to construct the temporary A("abc") directly into the vector, so that A's copy ctor won't be triggered when pushing the temporary object into vec.

Answer 1

If you have a compiler that supports rvalue references, it will be moved into the vector, which is sometimes quite cheap.

An alternative to that is to directly construct the object in the vector, which can be done with vec.emplace_back("abc");. This only invokes one constructor.

Both of these are C++11 features. Copy elision is not allowed here, so without those features the copy will still be made.

However, if the copy constructor has no observable side-effects (which it shouldn't have anyway), a smart compiler may still perform that optimisation, because the "as-if" rule allows any optimisation that results in the same observable behaviour. I don't know if any current compiler does that, though. If not, I doubt anyone will spend the effort to add such an optimisation because rvalue references put an end to that need.

Answer 2

In the general case, it cannot be done, it could potentially be done here as vector is a template and the code might be inlined, giving more information to the optimizer to do it's job and relieving some of the requirements of function calls.

In the general case, copy elision works by placing the two objects over the same location in memory and having just two names to refer to a single object. The problem in this case would be that one of the arguments must be located inside the vector (dynamically allocated, at a particular position), and the other is an argument to the function, which might be bound by the calling convention to a particular position in the stack. If that is the case, then the compiler will not be able to optimize the copy.