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

From:

Jeff Flinn <TriumphSprint2000@hotmail.com>

Newsgroups:

comp.lang.c++

Date:

Wed, 12 May 2010 09:28:14 -0400

Message-ID:

<hsea91$uij$1@news.eternal-september.org>

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