Return statement vs. accepting pointer to write into

Question

Possible Duplicate:
In C++, is it still bad practice to return a vector from a function?

In terms of performance, when needing to return'heavier' objects like std::vector or std::string from a function, is it recommended to use this form:

void func(std::vector<int> *dest)
{
}

instead of this form:

std::vector<int> func()
{
    std::vector<int> arr;
    // ...
    return arr;
}

I am assuming that the first form should be faster, but at the same time I've seen the second form often enough, the Qt API often returns a QString for example, probably because it is much more convenient or intuitive to use.

Also I've wondered if there are compiler optimizations which could remove the unnecessary copying of objects when using the return statement.

---

Edit

Are there any popular compilers still used today which do not perform the optimizations mentioned in the answers?

Answer 1

is it recommended to use [pass by pointer] instead of [return by value]?

No.

A modern C++ compiler performs named return value optimisation (NRVO) which effectively means that the compiler reliably elides the copy here. No copy is performed.

Note that this is regardless of which C++ version you are using: C++03 does it as well as C++11. The only thing that changed in C++11 is that the language makes it easier for libraries to make moving out of a value (as is happening here) efficient when no copy elision can be performed.

For return values, copy elision can normally be performed – it’s more relevant in other cases (passing parameters by value, for instance). There are exceptions though; the following code cannot use named return value optimisation. It can use a C++11 move though:

std::string foo() {
    std::string one = "Foo";
    std::string two = "Bar";

    if (rand() % 2 == 0)
        return one;
    else
        return two;
}

The reason is that now two code paths return different named objects; this prevents NRVO.

Answer 2

Return by value:

std::vector<int> func();

C++ allows for copy elision for situations just like this, and beyond that the new C++ defined move se­man­tics to make those operations cheap. Compilers generally implement this well. (With copy elision, your local arr will actually end up being constructed right in the recipient call site variable. This situa­tion is also known as "return value optimization".)

Answer 3

The rules allowing RVO and NRVO were present in the ARM (1990), so it would be surprising if any compiler didn't implement them.

More importantly, using out parameters (either pointers or references to non-const) is extremely unwieldy. Don't do it, until the profiler says that you really are having time problems because of the copying of the return value. At which point, overload the function, along the lines of:

void func( std::vector<int>& dest )
{
    //  ...
}

std::vector<int> func()
{
    std::vector<int> results;
    func( results );
    return results;
}

Then try both, at the location where the profiler says you are having problems, and chose the one which solves the problems (if it makes a difference).

I actually had to do this once, but that was sometime around 1991 or 1992. I haven't had to do it since, and for the last couple of years, I've been working on some pretty performance critical stuff; we still regularly return std::vector or our in house Matrix classes. Without the advantages of C++11, since not all of the targeted compilers support it.

Answer 4

std::vector<int> func();

With C++11, the above should be your function. The local std::vector object will be moved when the function returns. If possible, even move can be elided by the compiler.

In short, no worry. Return by value.