Ram wrote:
Victor Bazarov wrote: Ram wrote: [..]
I know its not difficult to roll out my own, just wondering whether
there's already a way to do it.
To do what? Extract "second"? Boost has an adapter for it, IIRC,
but if you're not currently using Boost, rolling your own is simpler
than waiting for it to tricle into the library implemenations.
<rant>
Programming always involves writing a bunch of small utility code
that serves some special needs. Why everybody keeps asking if all
those special needs have already been addressed in the library is
beyond me, aren't there books from which you can learn what is and
what isn't in the standard library? Do your homework before coming
here. Try not to use this newsgroup like a live reference manual
for C++... </rant>
I find your rant unjustified. [...]
I am sorry. Unjustified?! You asked (see above) whether there's already
a way to do it. "Already". What does that mean to you? "There": where?
We can only tell you about the language and about the library. That's
the only "there" where anything can be, AFA c.l.c++ is concerned.
I suggested (against my better judgement, apparently) to look at Boost.
But if you find Boost syntax unsatisfactory, well, how can we help?
If you know how to roll your own, isn't that "a way to do it" that is
"already" "there"? How much more elegant do you need to get beyond
a simple 'for' loop? I told you about the adapter that you can write.
Do you expect me to write it for you, or are you a programmer yourself?
OK, here you go:
-------------------
#include <map>
#include <iterator>
template<class mi, class t> struct key_iterator_tag
{
typedef std::input_iterator_tag iterator_category;
typedef t value_type;
typedef ptrdiff_t difference_type;
typedef difference_type distance_type; // retained
typedef t* pointer;
typedef t& reference;
mi iter;
key_iterator_tag(mi it) : iter(it) {}
bool operator !=(key_iterator_tag const& other) const {
return iter != other.iter;
}
bool operator ==(key_iterator_tag const& other) const {
return iter == other.iter;
}
key_iterator_tag& operator++() { ++iter; return *this; }
key_iterator_tag operator++(int) {
key_iterator_tag i(*this); ++iter; return i; }
t operator*() const { return (*iter).first; }
};
template<class mi, class t> struct mapped_iterator_tag
{
typedef std::input_iterator_tag iterator_category;
typedef t value_type;
typedef ptrdiff_t difference_type;
typedef difference_type distance_type; // retained
typedef t* pointer;
typedef t& reference;
mi iter;
mapped_iterator_tag(mi it) : iter(it) {}
bool operator !=(mapped_iterator_tag const& other) const {
return iter != other.iter;
}
bool operator ==(mapped_iterator_tag const& other) const {
return iter == other.iter;
}
mapped_iterator_tag& operator++() { ++iter; return *this; }
mapped_iterator_tag operator++(int) {
mapped_iterator_tag i(*this); ++iter; return i; }
t& operator*() { return (*iter).second; }
};
template<class mi>
key_iterator_tag<typename mi::iterator, typename mi::key_type>
key_begin(mi& m) {
return key_iterator_tag<typename mi::iterator, typename
mi::key_type>(m.begin());
}
template<class mi>
key_iterator_tag<typename mi::iterator, typename mi::key_type>
key_end(mi& m) {
return key_iterator_tag<typename mi::iterator, typename
mi::key_type>(m.end());
}
template<class mi>
mapped_iterator_tag<typename mi::iterator, typename mi::mapped_type>
mapped_begin(mi& m) {
return mapped_iterator_tag<typename mi::iterator, typename
mi::mapped_type>(m.begin());
}
template<class mi>
mapped_iterator_tag<typename mi::iterator, typename mi::mapped_type>
mapped_end(mi& m) {
return mapped_iterator_tag<typename mi::iterator, typename
mi::mapped_type>(m.end());
}
#include <iostream>
#include <list>
#include <algorithm>
int main(int argc, char** argv)
{
std::map<int,char> mic;
mic[1] = 'a';
mic[3] = 'b';
mic[2] = 'c';
std::list<int> li;
std::list<char> lc;
std::copy(key_begin(mic), key_end(mic), back_inserter(li));
for (std::list<int>::iterator i = li.begin(); i != li.end(); ++i)
std::cout << *i << std::endl;
std::copy(mapped_begin(mic), mapped_end(mic), back_inserter(lc));
for (std::list<char>::iterator i = lc.begin(); i != lc.end(); ++i)
std::cout << *i << std::endl;
}
-------------------
Now, the use of those is 'key_begin(somemap)' and 'key_end(somemap)' and
they are input iterators. Is that elegant enough? Probably not. You work
on improving the elegance, I'm done.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
