What is the best way to iterate over a map? (or any paired container)

When iterating over the elements of a map, frequently I only need the
map "value" (the second element of the pair).

Since I use STL algorithms a lot, I'd like to share with you two
particular versions of for_each and copy I implemented recently:

/** performs an operation in a range of any container of pair objects
 * for each second element of the pairs.
 * Usually, it is done in a map since the second element is the one
that contains the useful data.
 * @param start first iterator of the range
 * @param end last iterator of the range
 * @param oper a pointer to a function or a function object that
implements the operator().
 * @note oper class must have operator() with one parameter compatible
with the second element of the pairs
 * @return copy of the functor or the pointer to the function
 */
template<class InputIterator, class Functor>
inline Functor for_each_second(InputIterator start, InputIterator end,
Functor oper)
{
    for( ; start != end; ++start ) {
        oper((*start).second);
    }
    return oper;
}

/** copy the second value from a range of any container of pair objects

 * Usually, it is done in a map since the second element is the one
that contains the useful data.
 * @param start first iterator of the range
 * @param end last iterator of the range
 * @param output output iterator
 * @return copy of output iterator pointing to the next value to be
written
 */
template<class InputIterator, class OutputIterator>
inline OutputIterator copy_second(InputIterator start, InputIterator
end, OutputIterator output)
{
    for( ; start != end; ++start ) {
        *output++ = (*start).second;
    }
    return output;
}

These functions are pretty useful on my code, since I use a lot of maps
:)

But recently I had the need of a transform algorithm to use in a map.
It is a piece of cake implementing a "transform_second()" function
(*output++ =oper((*start).second);) BUT I don't want to reimplement
every STL algorithm I may need :-(

In the case of transform, I quickly solved the problem using
for_each_second (many STL algorithms can be simulated with for_each),
but I think it was a deselegant solution

:-(

However, in the bath tube, I though of a wierd solution: can we
implement a generic iterator wrapper for containers of std::pair<> that
returns only the .second when dereferencing? How?

If yes, no need for for_each_second() and the similars

something like:
myFunction(int);
....
std::map<string,int> map;
....
std::for_each(SecondWrap(map.begin()),SecondWrap(map.end()),myFunction);

What do you think about that?

Diego Martins
HP Researcher

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]