Re: for_each loop on a map without a functor

From:

"Daniel T." <daniel_t@earthlink.net>

Newsgroups:

microsoft.public.vc.stl, comp.lang.c++

Date:

Fri, 18 Jan 2008 12:03:00 -0800 (PST)

Message-ID:

<e69f2b7e-ad19-47b3-b0b9-b682484d0599@t1g2000pra.googlegroups.com>

On Jan 18, 5:45 am, nguillot <nicolas.guil...@gmail.com> wrote:

On 17 jan, 17:59, "Daniel T." <danie...@earthlink.net> wrote:

On Jan 17, 10:49 am, nguillot <nicolas.guil...@gmail.com> wrote:

Hello

I used to loop on a std::map<k, d> to act on the data (d) like that (d=

being a class with setIntMember method):

    typedef std::map<k, d> tMap;

    struct setIntMember
    {
        setIntMember(int j) : i(j) {}
        void operator()(tMap::value_type& pair)
{ pair.second.setIntMember(i); }
        int i;
    };

The loop being:
    for_each(m.begin(), m.end(), setIntMember(4));

I searched for a method to write all in the for_each loop (to avoid
increasing the functors).

We need a function returning the second member of the pair
tMap::value_type,
and their is the SGI template:

    template<typename _Pair>
    struct Select2nd : public unary_function<_Pair,
                          typename _Pair::se=

cond_type>

{
typename _Pair::second_type& operator()(_Pair& __x) co=

nst

{ return __x.second; }

const typename _Pair::second_type& operator()(const _P=

air&

__x) const
        { return __x.second; }
    };

But I didn't manage to write a single line to perform the for_each
loop, thanks to Select2nd with for_each, bind2nd and mem_fun and
mem_fun1

I didn't manage with boost::bind (on VC++ 6.0):
With boost, I can access the objects like that:
    for_each(m.begin(), m.end(),
        boost::bind(&d::Trace, boost::bind(&tMap::value_type::=

second,

_1)));
but the d::Trace method is called on a temporary object, so I cannot
modify the content of the objects contained in the map.

Some ideas?

Just use the functor you created. It's simple and clean... You might
want to generalized it a little bit:

template < typename Pair, typename Op >
class CallFuncOn2nd_t {
    Op fn;
public:
    CallFuncOn2nd_t( Op fn ): fn(fn) { }
    typename Op::result_type operator()( Pair& v ) const {
        return fn( v.second );
    }

};

template < typename Pair, typename Op >
CallFuncOn2nd_t<Pair, Op> callFuncOn2nd( Op fn ) {
    return CallFuncOn2nd_t<Pair, Op>( fn );

}

for_each(m.begin(), m.end(),

callFuncOn2nd<tMap::value_type>(bind2nd(mem_fun_ref(&d::setIntMember),
4)));

Ok, thanks, that's was exactly what I wanted to do!

But callFuncOn2nd<tMap::value_type>(bind2nd... fails to compile: the
second template argument seems to be required.
We must set the second template argument as a class that
has ::result_type, so I tried a std::unary_function<d, bool> (if
d::setIntMember returns a bool), but even if bind2nd could be
converted to unary_function (what fails) a unary function doesn't have
a () operator.
And I didn't manage write the second argument to be
std::binder2nd<std::binary_function<d*, int, bool> > or something like
that: it doesn't compile.

So the question: how write the for_each line?

Hmm, the for_each line I wrote above compiles fine for me. What
compiler are you using?