accumulare la somma di elementi nella cartina, utilizzando il valore

Question

dire che ho un

struct SMyStruct 
{ 
    int MULT; 
    int VAL; 

}; 


std::map<std::string, SMyStuct*> _idToMyStructMap; 

Ora voglio calcolare totale di tutte le SMyStuct, dove totale è definita come MULT1 * VAL1 + MULT2 * VAL2 per ogni elementi in idToMyStructMap.

Sembra che la funzione di accumulo sia una scelta naturale. Si prega di suggerire. grazie

No Amplificato per favore .... solo una 'moda ld stl

Answer 1

typedef std::map< std::string, SMyStruct* > string_to_struct_t; 

int add_to_totals(int total, const string_to_struct_t::value_type& data) 
{ 
    return total + data.second->MULT * data.second->VAL; 
} 

const int total = std::accumulate(
         _idToMyStructMap.begin(), 
         _idToMyStructMap.end(), 
         0, 
         add_to_totals); 

Answer 2

Una variazione sul tema sarebbe definire operatore + per la vostra struct, e poi basta usare std :: si accumulano nel la sua modalità predefinita.

int & operator+ (const int &lhs, const SMyStruct &rhs){ 
    return lhs + (rhs.MULT * rhs.VALUE); 
} 

Poi:

std::accumulate(_idToMyStructMap.begin(), _idToMyStructMap.end(), 0); 

Naturalmente, se operator+ ha un senso, in generale, per la vostra struct, allora che ci si vuole aggiungere sovraccarichi per l'utilizzo SMyStruct a sinistra pure, e/o fare loro modelli in modo da ottenere funzioni per int, float, double, long, ecc. tutto in un colpo solo. Come jalf menzionato nei commenti, se operator+ (o questa versione di esso) non ha senso in generale per la tua struttura, allora l'altra soluzione è migliore.

Answer 3

È inoltre possibile separare la funzionalità "Prendi secondo della coppia" da "calcolare MULT * VAL" e "aggiungere qualcosa ad un accumulatore".

Anche se non è necessario potenziare per fare ciò, hanno già creato una grande quantità di un quadro di programmazione "funzionale". Se non puoi usare boost, hai bisogno di un modello magico per conto tuo. Non troppo complicato, tuttavia,.

#include <map> 
#include <algorithm> 
#include <numeric> 
#include <functional> 
#include <iostream> 

Ora ritengo migliore per mettere la moltiplicazione all'interno della classe.

struct SMyStruct 
{ 
    int MULT; 
    int VAL; 
    long f() const { return MULT*VAL; } 
}; 

Creare un funtore generico per 'prendere il secondo di coppia':

// a 'take-second' functor 
template< typename at_pair > 
struct to_second_t : public std::unary_function< at_pair, typename at_pair::second_type > { 
    const typename at_pair::second_type& operator()(const at_pair & p) const { 
    return p.second; 
    } 
}; 

Questo sembra difficile, ma è solo un modo generico per dire: 'prima fare questo, quindi farlo con il risultato ':

// compose two functors (simplified) 
template< typename at_F, typename at_G > 
struct compose_t : public std::unary_function< typename at_F::argument_type, typename at_G::result_type >{ 
    at_F f; 
    at_G g; 
    compose_t(at_F& f, at_G& g): f(f), g(g) {} 

    typename at_G::result_type operator()(const typename at_F::argument_type& v) const { 
     return g(f(v)); 
    } 
}; 

template< typename at_F, typename at_G > 
compose_t<at_F, at_G> compose(at_F& f, at_G& g) { return compose_t<at_F,at_G>(f, g); } 



// compose two functors (a unary one, and a binary one) 
// 
template< typename at_F, typename at_G > 
struct compose2_t : public std::binary_function< typename at_F::first_argument_type, typename at_G::argument_type, typename at_G::result_type >{ 
    at_F f; 
    at_G g; 
    compose2_t(at_F& f, at_G& g): f(f), g(g) {} 

    typename at_G::result_type operator()(const typename at_F::first_argument_type& a1, const typename at_G::argument_type& v) const { 
     return f(a1, g(v)); 
    } 
}; 

template< typename at_F, typename at_G > 
compose2_t<at_F, at_G> compose2(at_F& f, at_G& g) { return compose2_t<at_F,at_G>(f, g); } 

E, infine, mettere tutto in pratica:

int main() 
{ 
    typedef std::map<int, SMyStruct > tMap; 
    tMap m; 
    SMyStruct s = {1,2}; 
    m[1].VAL = 1; m[1].MULT = 3; 
    m[2].VAL = 2; m[2].MULT = 10; 
    m[3].VAL = 3; m[3].MULT = 2; 

    // mind, this is not LISP (yet) 
    long total = std::accumulate(m.begin(), m.end(), 0, 
    compose2( 
     std::plus<int>(), 
     compose( 
     to_second_t<tMap::value_type>(), 
     std::mem_fun_ref(&SMyStruct::f))) 
    ); 

    std::cout << "total: " << total <<std::endl; 
    return 0; 
}