Re: How to pass STL containers (say a vector) ?

From:

"peter koch" <peter.koch.larsen@gmail.com>

Newsgroups:

comp.lang.c++

Date:

20 May 2006 13:37:12 -0700

Message-ID:

<1148157432.201838.265110@i39g2000cwa.googlegroups.com>

Daniel T. skrev:

In article <1148077619.867034.182600@g10g2000cwb.googlegroups.com>,
"peter koch" <peter.koch.larsen@gmail.com> wrote:

Daniel T. skrev:

In article <1148070525.301764.67280@u72g2000cwu.googlegroups.com>,
"peter koch" <peter.koch.larsen@gmail.com> wrote:

Daniel T. skrev:

In article <1148063503.729070.325510@j33g2000cwa.googlegroups.com>,

[snip]

I beg to differ, std::copy does return a container in its own way...

Well... I just notice the line above. I agree that std::copy might make
the data copied available somehow. The difference is one of words. I
meant return as used in a C++ program whereas you seemingly mean return
in the sense that the data will afterwards be available to the caller.

True.

So we agree here ;-)

vector<int> foo;
copy( istream_iterator<int>( cin ), istream_iterator<int>(),
back_inserter( foo ) );

The data in foo was returned...

So you mean that the data was returned in foo? In that case we simply
have a different perception of "returning values". To me, std::copy
does not return data in foo.

What about transform?

Perhaps this example better demonstrates what i mean?
vector<int> foo;
foo.push_back(117);
copy( istream_iterator<int>( cin ), istream_iterator<int>(),
back_inserter( foo ) );

copy definitely does not return its data in foo.

How so? All the data collected inside the copy function is given to the
caller through foo...

Surely. But std::copy did not return the data - it simply put them into
some iterator.

It is a pretty common method of returning multiple datum to the caller.

In other words when you want to pass in a container:

tempalte < typename InIt >
void func( InIt first, InIt last );

Fine! And now let func remove the second element.

The same way std::remove does it.

That does not remove the data from the container.

True. Your point?

My point is that there is a difference between having a container and a
pair of iterators. Sometimes a pair of iterators just can't do the job.

when you want to return a container:

template < typename OutIt >
void func( OutIt first );

It still does not return a container.
template <class container> void normalise_container(container const&
c);
template <class container> void print_container(container const& c);
print_container(normalise_container(func(???)));

template < typename FwIt > void normalize( FwIt first, FwIt last );
template < typename FwIt > void print( FwIt first, FwIt last ) {
copy( first, last, ostream_iterator<int>( cout, " " ) );
}

normalize( vec.begin(), vec.end() );
print( vec.begin(), vec.end() );

You get the same functionality but with an added complexity:
std::vector<int> vec;
func(vec);
normalize( vec.begin(), vec.end() );
print( vec.begin(), vec.end() );

(forgetting that vec is still in scope).

Versus:
print(normalise(func()));

One simple line. Efficient, leaves no mess.

Odd, in your code above, "normalise_container" returns void yet you are
passing its return to print? There is obviously a debate about whether
such a return is efficient.

Obviously, normalise_container should have returned a vector. I presume
you could guess that just as I did guess the meaning of your
"tempalted" function declaration ;-)

I will happily admit that templating to the container rather than two
iterators is a great idea, but templating to two iterators is more
idiomatic...

I do not intend to template anything at all. If you read the original
post, you'll understand why. The advice was given to a newcomer to C++
and in situations like that. you should avoid recommending templates
just as you should avoid iterators which do complicate things quite a
lot.

/Peter