«

Let v be:

vector<pair<string, size_t> > v;

sum = 0;
for (size_t k = 0; k < v.size(); k++)
{
sum += v[k].second;
}


Is it possible to compute sum using std::accumulate (i.e. not using
for-loop)?



Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

http://www2.roguewave.com/support/do...ccumulate.html


greets Boris

On Apr 3, 1:24 pm, Alex Vinokur <ale...@users.sourceforge.net> wrote:
> Let v be:

> vector<pair<string, size_t> > v;

> sum = 0;
> for (size_t k = 0; k < v.size(); k++)
> {
> sum += v[k].second;
> }

> Is it possible to compute sum using std::accumulate (i.e. not using
> for-loop)?

I'm pretty sure that Boost iterators have something which
supports this, probably right out of the box, but at the very
least transform_iteratror in collaboration with bind will do the
trick.

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

In article <21e0cb00-9ae3-4f87-805c-13c6679fe9a3
@i36g2000prf.googlegroups.com>, says...
>
> Let v be:
>
> vector<pair<string, size_t> > v;
>
> sum = 0;
> for (size_t k = 0; k < v.size(); k++)
> {
> sum += v[k].second;
> }
>
> Is it possible to compute sum using std::accumulate (i.e. not using
> for-loop)?

Yes, though it's open to question whether it's really any improvement:

typedef std:air<std::string, size_t> p;

struct add_second : std::binary_function<size_t, size_t, p> {
size_t operator()(size_t a, p const &b) { return a+b.second; }
};

size_t sum = std::accumulate(v.begin(), v.end(), 0, add_second());

Using Boost.lambda, I believe you should also be able to do something
like this:

size_t sum=std::accumulate(v.begin(), v.end(), 0, var(_1).second);

--
Later,
Jerry.

The universe is a figment of its own imagination.

Alex Vinokur a écrit :
> Let v be:
>
> vector<pair<string, size_t> > v;
>
> sum = 0;
> for (size_t k = 0; k < v.size(); k++)
> {
> sum += v[k].second;
> }
>
>
> Is it possible to compute sum using std::accumulate (i.e. not using
> for-loop)?

You can use a functor to project on the second element of the pair:

template<class Pair>
class pair_get2nd
{
typedef Pair argument_type;
typedef typename Pair::second_type result_type;

const result_type& operator()(const argument_type& t)const
{
return t.second;
}
};

And then

typedef vector<pair<string, size_t> > my_vector;
my_vector v;
sum = std::accumulate(v.begin(), v.end(),0,
pair_get2nd<my_vector::value_type>());


Michael