Re: How to pass STL containers (say a vector) ?
In article <1148157432.201838.265110@i39g2000cwa.googlegroups.com>,
"peter koch" <peter.koch.larsen@gmail.com> wrote:
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 ;-)
Yes, I assumed as much. Hence the comment about the debate. There are no
efficiency concerns about the use of iterators in this context.
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.
I realize that the OP is somewhat new to C++, that is why I recommended
he use idiomatic code. The standard way of passing containers to and
from functions (ie the way the *standard* passes containers to and from
functions) is through the use of iterators.
I think it is wrong to avoid iterators when working with beginners,
better iterators than bald pointers IMO. I also think it is wrong to
avoid templates in simple code like this (though I don't expect new
people to understand using them in Policy-Based Design situations.) If
however, I did want to avoid templates, I would still recommend iterator
based container passing. That way, at least the calling code will look
idiomatic.
We have a difference of opinion. I'll teach my way, you will teach your
way. When my students first come across code using the standard
algorithms they will think nothing of it.