Re: What's your preferred way of returning a list of items?
On 13 May, 02:44, "Alf P. Steinbach" <al...@start.no> wrote:
On 13.05.2010 00:40, * James Kanze:
On May 12, 11:40 am, "Alf P. Steinbach"<al...@start.no> wrote:
On 12.05.2010 10:18, * DeMarcus:
Here are a couple of ways to return some list of items.
struct A
{
};
std::vector<A> aList; // Some list of items.
// Returning a copy.
std::vector<A> getList() { return aList; }
This one is OK, and will be efficient with modern compiler.
That depends on the context and the compiler. I've found
that in many contexts, if the vector is large, it's not
efficient with g++ or VC++ (or Sun CC).
Huh, that's news to me.
I'm pretty skeptical about that claim since both g++ and MSVC
do RVO optimization by default, but I'll try to remember to
check this.
If you're talking about comparing it with a situation where
you can avoid reallocation of the vector's buffer then that
doesn't depend on the compiler.
I'm talking about actual use. I know that both g++ and VC++ do
RVO---I found a bug in the code generation for RVO in VC++,
remember. I also know, from actual measurements, that RVO
doesn't address all of the issues, and can't be used all of the
time. (VC++ will not do it if there is more than one return in
the function, for example.)
void getList( std::vector<A>& v )
{
std::copy( aList.begin(), aList.end(), v.begin() );
}
This one's signature is OK as an opt-in alternative to the
first one (i.e. provide /both/, or just the first one).
However, the implementation is incorrect unless you assume
that the argument is of exactly the right size for the result
(and that assumption would be unrealistic, to put it mildly).
You could write it like
void getList( std::vector< A>& v )
{
std::vector< A>( aList.begin(), aList.end() ).swap( v );
}
Or simply use clear and a back_inserter. Or resize the
target first. The optimal solution will depend on context.
I like this way as a "default" for this function signature
because it guarantees to get rid of the old buffer allocation
(so that one does not hang on to the largest buffer size
forever), and because it's simplest.
Depending on the context, getting rid of the old buffer
allocation can be considered a weakness. If you're calling the
function often enough, with the same vector, it's a definite
performance advantage not to get rid of the old buffer.
In our code, we have some cases where we call it a couple of
million times, in a loop, with the same vector, and the results
always have the same size. We create the vector with the
appropriate size before hand, and use assignment in the
function. In our particular context, that's the fastest
solution. In other contexts, maybe not. But since you're only
doing this because you have a performance problem, you may want
to try several different solutions, measuring each, and use the
one which is best in your context.
[...]
Yes and no. The "preferred" way of returning something
(anything, including a list of whatever) is to return it. You
only vary from that when the profiler says you must. In which
case, you have the context, and you adopt the solution most
suited to the context.
This seems to conflate two different meanings of "return".
Of course:-).
--
James Kanze