"Paul MG" <paulmg@digitalbrain.com> wrote in message
news:265e380f.0307250256.588e07d0@posting.google.c om...[color=blue]
> Thanks for your thoughts guys.
>
> There seem to be two major threads of response:
>
> 1) Use C (ie explicit loops). I realise that this can be a tradeoff[/color]
worth[color=blue]
> making, I just wanted to push a little harder toward StlStyle to see[/color]
if[color=blue]
> we could come up something nicer.
>
> 2) Don't use std::accumulate() to do your accumulation, use[/color]
std::for_each()[color=blue]
> and a bespoke functor. A neat solution I agree but it bugs me not to[/color]
use[color=blue]
> std::accumulate() to accumulate a range.
>
> What I think I want to be able to do though, is something like:
>
> int sumKeys(const map<int, string>& m) {
> return accumulate(m.begin(), m.end(), 0,
> someBinding(plus<int>,
> mem_fun_ref(&pair<int,[/color]
string>::first))[color=blue]
> );
> }
>
> Because it seems more expressive of intent. It says
>
> return the *accumulation* of *m* *adding up* the *first* of each[/color]
element.[color=blue]
>
> Rather than
>
> initialize an accumulator variable to zero
> initialize an iterator to the first element of *m*
> while that iterator is not at the last element of *m*
> add the *first* of the pointed-at element to my accumulator variable
> increment that iterator
> return the value of my accumulator variable
>
> See how sparse the actual algorithm core is amongst all the surrounding[/color]
stuff[color=blue]
> in the second version?
>
> Obviously I am biased here, perhaps someone else would like to write out[/color]
the[color=blue]
> two 'scripts' and somehow show that an alternative to my version is more
> expressive?
>
> Of course, there is the slight problem that I haven't quite worked out[/color]
what[color=blue]
> someBinder() is in my solution ;). That's what I'm posting to find out I[/color]
guess![color=blue]
>[/color]
Because (as you pointed out in your original post) std::pair doesn't define
member functions to access
its member variables, the mem_fun and mem_fun_ref helpers don't help, so I
don't think this can be
done as a one-liner.
Once you've defined the symantics of adding a pair<int, string> to an int,
however, it's all rather easy:
---snip---
namespace std {
inline int operator+(const int& acc, const std::pair<int, std::string>&
p) {
return acc + p.first;
}
}
std::map<int, std::string> foo;
int total = std::accumulate(foo.begin(), foo.end(), 0);
---snip---
[color=blue]
> thanx for feedback,
>
> paul.[/color]
--
Roger
