, नक्शे में तत्वों की राशि जमा मूल्य

Question

का उपयोग कर

मैं एक

struct SMyStruct 
{ 
    int MULT; 
    int VAL; 

}; 


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

है अब मैं सभी SMyStuct, जहां कुल में प्रत्येक तत्व के लिए के रूप में MULT1 * VAL1 + MULT2 * VAL2 परिभाषित किया गया है की कुल गणना करना चाहते कहो idToMyStructMap।

लगता संचित समारोह की तरह एक प्राकृतिक विकल्प है। कृपया सुझाव दे। धन्यवाद

नहीं बूस्ट कृपया .... सिर्फ एक 'ld फैशन एसटीएल

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

विषय पर एक बदलाव ऑपरेटर + अपने struct के लिए परिभाषित करने के लिए हो सकता है, और फिर बस एसटीडी का उपयोग :: में जमा इसका डिफ़ॉल्ट मोड।

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

फिर

:

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

बेशक

, अगर operator+ अपने struct के लिए सामान्य रूप में समझ में आता है, तो आप के रूप में अच्छी छोड़ दिया पर SMyStruct प्रयोग करने के लिए भार के जोड़ सकते हैं, और/या बनाने उन्हें टेम्पलेट्स ताकि आप एक शॉट में int, float, double, long, आदि के लिए फ़ंक्शंस प्राप्त कर सकें। टिप्पणियों में आधे उल्लेख के रूप में, यदि operator+ (या इसका यह संस्करण) आपकी संरचना के लिए सामान्य रूप से समझ में नहीं आता है, तो दूसरा समाधान बेहतर है।

Answer 3

आपको यहां से 'MULT गणना * VAL' 'जोड़ी की दूसरी ले' कार्यक्षमता अलग कर सकते हैं और 'एक संचायक के लिए कुछ जोड़ें'।

हालांकि आप यह करने के लिए बढ़ावा देने की जरूरत नहीं है, वे पहले से ही एक 'कार्यात्मक' प्रोग्रामिंग ढांचे के एक महान सौदा बनाया। यदि आप बूस्ट का उपयोग नहीं कर सकते हैं, तो आपको अपने स्वयं के कुछ टेम्पलेट जादू की आवश्यकता है। भी जटिल नहीं है, हालांकि।

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

अब मैं इसे बेहतर वर्ग के भीतर गुणा डाल करने के लिए समझना।

// 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; 
    } 
}; 

यह मुश्किल लग रहा है, लेकिन केवल कहने का एक सामान्य तरीका है::

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

'जोड़ी की दूसरी ले' के लिए एक सामान्य functor बनाएँ 'पहले ऐसा करते हैं, तो परिणाम के साथ कि ':

// 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); } 

और अंत में, यह सब व्यवहार में डाल:

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; 
}