कंटेनर में सभी तत्वों के लिए सदस्य फ़ंक्शन के परिणाम को योग करने का सबसे अच्छा तरीका क्या है?

Question

मान लें कि मेरे पास निम्न ऑब्जेक्ट है:

struct Foo 
{ 
    int size() { return 2; } 
}; 

vector<Foo> में सभी ऑब्जेक्ट्स का कुल size प्राप्त करने का सबसे अच्छा तरीका (सबसे रखरखाव योग्य, पठनीय, आदि) क्या है? मैं अपना समाधान पोस्ट करूंगा लेकिन मुझे बेहतर विचारों में दिलचस्पी है।

अद्यतन:

अब तक हमारे पास है:

• std :: संचय और एक मज़ेदार
• std :: संचय और एक लैम्ब्डा अभिव्यक्ति
• plain ol for for lop

क्या कोई अन्य व्यावहारिक समाधान है? क्या आप boost::bind या std::bind1st/2nd का उपयोग करके कुछ बनाए रखने योग्य बना सकते हैं?

Answer 1

अपने खुद के सुझाव के अलावा, अपने संकलक C++ 0x लैम्ब्डा भाव का समर्थन करता है, तो आप इस छोटा संस्करण काम कर सकते हैं:

std::vector<Foo> vf; 

// do something to populate vf 


int totalSize = std::accumulate(vf.begin(), 
           vf.end(), 
           0, 
           [](int sum, const Foo& elem){ return sum + elem.size();}); 

Answer 2

std::accumulate और एक मजेदार का उपयोग करें।

#include <functional> 
#include <numeric> 

struct SumSizes : public std::binary_function<int, Foo, int> 
{ 
    int operator()(int total, const Foo& elem) const 
    { 
     return total + elem.size(); 
    } 
}; 

std::vector<Foo> vf; 

// do something to populate vf 

int totalSize = std::accumulate(vf.begin(), 
           vf.end(), 
           0, 
           SumSizes()); 

Answer 3

यहाँ नीचे करने वाली पृथ्वी समाधान है:

typedef std::vector<Foo> FooVector; 
FooVector vf; 
int totalSize = 0; 
for (FooVector::const_iterator it = vf.begin(); it != vf.end(); ++it) { 
    totalSize += it->size(); 
} 

Answer 4

मुझे बूस्ट इटरेटर्स लालित्य मिलते हैं, हालांकि वे थोड़ा वर्बोज़ हो सकते हैं (श्रेणी-आधारित एल्गोरिदम इसे बेहतर बना देंगे)। इस मामले में transform iterators काम कर सकते हैं:

#include <boost/iterator/transform_iterator.hpp> 
//... 

int totalSize = std::accumulate(
    boost::make_transform_iterator(vf.begin(), std::mem_fn(&Foo::size)), 
    boost::make_transform_iterator(vf.end(), std::mem_fn(&Foo::size)),0); 

संपादित करें: "boost::bind(&Foo::size,_1)" की जगह द्वारा "std::mem_fn(&Foo::size)"

संपादित करें: मैं बस में पाया गया कि Boost.Range पुस्तकालय रेंज एल्गोरिदम लागू करने के लिए अद्यतन किया गया है!

#include <boost/range/distance.hpp> // numeric.hpp needs it (a bug?) 
#include <boost/range/numeric.hpp> // accumulate 
#include <boost/range/adaptor/transformed.hpp> // transformed 
//... 
int totalSize = boost::accumulate(
    vf | boost::adaptors::transformed(std::mem_fn(Foo::size)), 0); 

नोट:: प्रदर्शन लगभग एक ही कर रहे हैं (मेरी टिप्पणी देखें): यहाँ एक ही समाधान का एक नया संस्करण है आंतरिक रूप से, transformedtransorm_iterator उपयोग करता है।

Answer 5

सी ++ 11 (और आगे) का उपयोग करते हुए पाश

std::vector<Foo> vFoo; 
// populate vFoo with some values... 
int totalSize = 0; 
for (const auto& element: vFoo) { 
    totalSize += element.size(); 
}