从函数返回值：reference vs struct

Question

I'm new to programming and I'm studying the C++ programming language using the book : Programming principles and practice using C++. I'm here today because at the end of chapter 8, the author focuses on functions and proposes an exercise to invite the learner to think about the better solution to a problem :

Write a function that finds the smallest and the largest element of a vector argument and also computes the mean and the median. Do not use global variables. Either return a struct containing the results or pass them back through reference arguments. Which of the two was of returning several values do you prefer and why ?

Now, usually I wouldn't define a single function to perform several actions but in this case I have to create just one function and think about how to return several values. My first approach was to create a function that takes reference arguments like this :

void my_func(
    vector<double>& numbers,
    double& min,
    double& max,
    double& mean,
    double& median
);

But going on with writing the program I started to think that this solution used too many arguments and maybe the other solution proposed (using struct ) would be better. How would you use a struct to solve this problem ? How do you return several values from a function ?

Answer 1

Using struct for this problem is simple: define a struct for the return type, and use it, like this:

struct stats {
    double min;
    double max;
    double mean;
    double median;
};
stats my_func(vector<double>& numbers) {
    stats res;
    ...
    res.min = ...
    res.max = ...
    res.mean = ...
    res.median = ...
    return res;
}

The tradeoff here is that in exchange for having a much simpler function signature, the users of your function need to extract the elements that they want one by one.

But what about if the struct is really complex and the cost of copying becomes too expensive?

It takes a structure of extreme size for copying to become too expensive in comparison to the "payload" CPU time of your function. On top of that, C++ optimizer reduces the copying costs by employing copy elision and return value optimization strategies when you do this:

stats s = my_func(numbers);

When the struct becomes so gigantic that you don't want to copy it, combine the two approaches like this:

void my_func(vector<double>& numbers, stats& res);

Answer 2

Declare the struct

ie

struct stats {
   double min;
   double max;
   double mean;
   double median;
};

Then

stats my_func(vector<double>& numbers);

The function will be like this

stats my_func(vector<double>& numbers) {
    stats return_value;

     // Fill in the structure

    return return_value;
}

Answer 3

Well you just return a struct.

struct res {
   double min; 
   double max;
   double mean;
   double median;
};

res my_func(vector<double>& numbers) {
    res result;
    // do stuff, put result in in result.min etc

    return result;
}

The other can be done in a similar way:

void my_func(vector<double>& numbers,
             res& result)
{
    // the same code except no return value

    return;
}

Now for the question in your task (which I shall not answer - because it's a question what you prefer) I'd like to mention what the technical difference is.

When returning a struct it means you will possibly create a temporary copy of the result struct (it may also result in two objects res one for the caller and one for my_func to work with). While the other approach means that you pass to the function essentially addresses where to put the result. With a "good" implementation you may end up with the same code.