Efficiency of output parameter vs return value on the stack for stl data structures

Question

lets say I have the functions

std::Vector<Point> calculate() {
   std::Vector<Point> points; //do stuff with points
   return points;
}

and

void calculate(std::Vector<Point>& points) {
   //do stuff with points
}

So my question is specific to objects initialized on the stack, and are stl objects. Is there any difference in performance, and what is the popular method of doing it

regards

Answer 1

Taking the value as a reference parameter has the following properties:

1. No copying, moving, or any other operation will be done.
2. The return value cannot be immediately discarded on the user's side. They can't just shove a temporary at your function's reference parameter or something. They must declare a variable, and therefore they must give it a name which will live within the current scope.
3. The API suggests that the value is an input/output parameter. That is, there is a value being passed in which will be read and written. If that is not the case, then using it represents a sub-optimal API design element.

Returning the value has the following properties:

1. If copy elision is not available (either due to the nature of the function's implementation, a poor compiler, or that the return value is not initializing a new value), then the return value will be moved. Not copied. Movement is not free, but generally it is not much more expensive than a few pointer copies. No new objects or memory will be allocated or deallocated.
2. The API enforces the output nature of the value. There is no way for the user to play with the output it passes in because it doesn't pass anything in. Similarly, there is no way for the function to read any values because it doesn't take anything in. It is an output value, period; the function generates it and returns it.
3. The return value can be discarded immediately at the user's discretion. Obviously if users are doing this a lot, it suggests that something is wrong, but it is up to the user to decide if they want to keep the output value or not. The C++17 [[nodiscard]] attribute can be used in cases where discarding the value is categorically incorrect.

Answer 2

The performance will very likely be the same, because of copy elision.

What the two methods express is different

std::vector<Point> calculate()

returns a vector (probably based on some parameters).

void calculate(std::vector<Point>& points)

modifies an existing vector (again, probably based on parameters).

Answer 3

My humble opinion: big return values create more problems than solve... they look simpler, they are more concise in the calling segment, but rvalue references would be avoided.

If you look at old, but designed for efficiency software packages like BLAS and LAPACK, big objects are passed by reference and return values are just error flags or doubles (ddot for example in BLAS).

The shortcoming is that expressiveness will be reduced, but that is a small cost, since resources like memory allocation will move upstream.

C++ can be significantly simplified in terms of syntax and resource management. Passing non-const references has a cost in terms of "prettiness" and code length but it's efficient.

Answer 4

In Google coding conventions, they recommend using return value rather than output parameter. It's because return value improve readability and often provide the same or better performance.

For readability, I think It's obvious. With output parameter, you have to look over all parameter and determine which ones use for output parameter.

For performance, Scot Meyer said 'Use const whenever possible' in his book. We can't use const for output parameter. Moreover, modern compilers use return value optimization (RVO) or named return value optimization (NRVO) to optimize away the copy operation.

Read these for more details: [1][2]