Re: What's your preferred way of returning a list of items?
Sousuke wrote:
On May 12, 3:18 am, DeMarcus <use_my_alias_h...@hotmail.com> wrote:
Hi,
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; }
void getList( std::vector<A>& v )
{
std::copy( aList.begin(), aList.end(), v.begin() );
Isn't that just a more complicated and unsafe way of doing:
v = aList;
?
}
void getList( std::vector<A>* v )
{
std::copy( aList.begin(), aList.end(), v->begin() );
}
I recently started a thread on that subject (whether "out" parameters
should be pointers instead of references):
http://groups.google.com/group/comp.lang.c++/browse_thread/thread/697f5fbff47a94e3#
It seems most agreed that it's a dumb guideline.
I don't think it's a /dumb/ guideline. I was thinking in those guideline
terms myself before. I thought that it would be easy to see whether a
variable would be altered if providing the address of it. E.g.
fnc( &myVar );
would give a hint of that myVar is going to be modified. However, if you
provide something that already is a pointer it would look like this.
fnc( myVar );
And therefore such guideline could be misleading.
// Returning a reference to aList.
const std::vector<A>& getList() { return aList; }
That's the preffered way if the object being returned is a member of a
class (which means that the method is just a simple accessor
(getter)). More generally, it's ok as long as the object's lifetime is
well-defined and known to the caller (in the case of a member
variable, the lifetime is the same as that of its containing object).
const std::vector<A>::const_iterator& getList()
{
return aList.begin();
}
Seems pointless.
Do you know more ways to return a list? What's your preferred way to
return a list of items?
Either "vector<A> getList()" or "void getList(vector<A>&)" if I need
copying, or "const vector<A>& getList() const" (and possibly a non-
const overload) if the returned object is a member variable.
Sometimes one doesn't need to copy but to return a newly created
container. E.g.
std::vector<std::string> getVector()
{
std::vector<std::string> hwVector;
hwVector.push_back( "Hello World" );
return hwVector;
}
I wonder how the new rvalue reference will be used with return values.
Like this?
std::vector<std::string>&& getVector()
{
std::vector<std::string> hwVector;
hwVector.push_back( "Hello World" );
return std::move( hwVector );
}
Do you know?