Re: What's your preferred way of returning a list of items?

From:

DeMarcus <use_my_alias_here@hotmail.com>

Newsgroups:

comp.lang.c++

Date:

Wed, 12 May 2010 15:51:42 +0200

Message-ID:

<4beab271$0$285$14726298@news.sunsite.dk>

Jeff Flinn wrote:

DeMarcus wrote:

?? Tiib wrote:

On May 12, 11: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() );

}

void getList( std::vector<A>* v )
{
    std::copy( aList.begin(), aList.end(), v->begin() );

}

// Returning a reference to aList.
const std::vector<A>& getList() { return aList; }

const std::vector<A>::const_iterator& getList()
{
    return aList.begin();

}

Do you know more ways to return a list? What's your preferred way to
return a list of items?

Also, here comes another trickier one. Let's say I have a map instead
and want to return the keys.

std::map<std::string, A> aMap;

// Returning a copy of the keys.
std::vector<std::string> getList()
{
    std::vector<std::string> aKeys;
    auto keysEnd = aMap.end();
    for( auto i = aMap.begin(); i != keysEnd; ++i )
       aKeys.push_back( (*i).first );
    return aKeys;

}

void getList( std::vector<std::string>& v )
{
    auto keysEnd = aMap.end();
    for( auto i = aMap.begin(); i != keysEnd; ++i )
       v.push_back( (*i).first );

}

void getList( std::vector<std::string>* v )
{
    auto keysEnd = aMap.end();
    for( auto i = aMap.begin(); i != keysEnd; ++i )
       v->push_back( (*i).first );

}

// But is it even possible to return a reference to
// the keys in a map?

const std::vector<std::string>& getList() { /* What here? */ }

const std::vector<std::string>::const_iterator& getList()
{
    /* What here? */

}

How do you usually deal with these kind of list returns?

Usually...

I avoid writing functions that are getters, copiers or even worse ...
setters, because these indicate lousy design. I usually try my best to
have interface that allows operations that make sense to do with the
objects of given type and not interface that allows mechanical
setting, getting and copying of the properties of objects.

Ok, great. Actually I'm also very considered with clean design, but
sometimes I find it impossible to do anything else than returning a
container.

I'm playing around with a command in Linux called backtrace_symbols.
The command gives you the stack trace. Now I want to wrap that somehow
and this is what I've made so far.

std::vector<std::string> getStackTrace();

How would you do this? Like this

std::vector<std::string> stackTrace();

or provide functions that can be applied to the stack trace, e.g.

std::ostream& operator<<( std::ostream&, const StackTrace& );

Your implication here of a StackTrace class would be my choice. Along
with StackTraceItem class and whatever other classes embody the domain
entities. Then as you've shown each of these classes could be
streamable. The StackTrace class could then provide a container
interface including the expected typedefs, iterators and methods.

Jeff

I agree with you that one should not be afraid of making classes of even
the simplest things. But sometimes I just feel to be lazy, and in this
case the stack trace is just a list of text, so just to get up running
with a decent solution I chose to just provide a container.

Then came my mind block; I always return something like
std::vector<std::string>, but is that the best way to return a
container? How are containers returned with the new C++0x rvalue
reference for instance?