Is returning a vector slower than passing by reference?

Question

In the old days we were trained to use result parameters passed by reference in order to avoid unnecessarily copying data around.

However with smarter compilers - and particular the extensions to C++11 is this still required?

Specifically, is there any reason in 2018 with modern C++11/C++14 compilers to (still) use

void Filter(vector<CObject*> &elements, vector<CObject*> &outElements);

instead of simply returning the vector, i.e.

vector<CObject*> Filter(vector<CObject*> &elements);

Thanks in advance for all insights!

Answer 1

and particular the extensions to C++11 is this still required?

No. In the best case scenario, RVO (return value optimization) will kick in, which will completely elide any copy/move.

In the worst case scenario, the object will be moved out of the function. Moves for std::vector are very cheap (comparable to just a few pointer swaps).

This is because the expression Filter(some_input) is an rvalue of type std::vector<CObject*>, and std::vector's constructor has an overload accepting an rvalue reference: see (6) here.

Answer 2

In the old days we were trained to use result parameters passed by reference in order to avoid unnecessarily copying data around.

Actually, even when one was using an old C++ compiler this was pretty poor advice: write for clarity first and efficiency second.

In particular, returning by a reference value prevents making the values in the caller const (which improves clarity and provides other optimization opportunity).

Of course, if profiling shows this was a performance bottleneck, then one had to make the necessary changes. With RVO and NRVO (which are now pretty common), and move semantics as a back-up it is now very unlikely to be a performance bottleneck.