valores acumulan MultiMap

Question

Tengo un multimap definido por

typedef std::pair<int, int> comp_buf_pair; //pair<comp_t, dij>
typedef std::pair<int, comp_buf_pair> node_buf_pair;
typedef std::multimap<int, comp_buf_pair> buf_map; //key=PE, value = pair<comp_t, dij>
typedef buf_map::iterator It_buf; 
int summ (int x, int y) {return x+y;}


int total_buf_size = 0;
std::cout << "\nUpdated buffer values" << std::endl;
for(It_buf it = bufsz_map.begin(); it!= bufsz_map.end(); ++it)
{
    comp_buf_pair it1 = it->second;
    // max buffer size will be summ(it1.second)
    //total_buf_size = std::accumulate(bufsz_map.begin(), bufsz_map.end(), &summ); //error??
    std::cout << "Total buffers required for this config = " << total_buf_size << std::endl;
    std::cout << it->first << " : " << it1.first << " : " << it1.second << std::endl;

}

Me gustaría resumir todos los valores apuntados por it1.second ¿Cómo puede la std :: acceso a la función de acumular los valores de segundo iterador?

Answer 1

Su problema es con la función Summ, que realmente necesita algo mejor que eso para ser capaz de manejar 2 tipos no coincidentes.

Si tienes suerte, esto podría funcionar:

int summ(int x, buf_map::value_type const& v) { return x + v.second; }

Si tiene la mala suerte (en función de cómo se implementa accumulate), siempre se puede:

struct Summer
{
  typedef buf_map::value_type const& s_type;
  int operator()(int x, s_type v) const { return x + v.second.first; }
  int operator()(s_type v, int x) const { return x + v.second.first; }
};

Y a continuación, el uso:

int result = std::accumulate(map.begin(), map.end(), 0, Summer());

Answer 2

creo que sólo tendrá que cambiar su función summ tomar el mapa value_type lugar. Esto es totalmente no probado, pero debe dar la idea.

int summ (int x, const buf_map::value_type& y) 
{
    return x + y.second;
}

Y lo llaman:

total_buf_size = std::accumulate(bufsz_map.begin(), bufsz_map.end(), 0, &summ);

Answer 3

¿Por qué te enredar con pares que contiene pares? Que es demasiado complicado y que terminará haciendo errores. ¿Por qué no definir una estructura?

Answer 4

  

Accumulate es una generalización de la suma:. Que calcula la suma (o alguna otra operación binaria) de init y todos los elementos en el [first, last) gama

     

... El resultado es inicializado primero en init. Entonces, para cada i iterador en [first, last), con el fin de principio a fin, se actualiza por result = result + *i (en la primera versión) o result = binary_op(result, *i) (en la segunda versión).

     

Sgi.com

Su intento era ni la primera o segunda versión, se ha perdido la parte init

total_buf_size = std::accumulate(bufsz_map.begin(), bufsz_map.end(), 0, &summ);