Bir kapsayıcıdaki tüm öğeler için üye işlevinin sonucunu özetlemenin en iyi yolu nedir?

Question

Şu nesneye sahip olduğumu varsayalım:

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

vector<Foo> içindeki tüm nesnelerin toplam size değerini elde etmek için en iyi yol nedir (en çok okunabilir, okunabilir, vs.)? Çözümümü göndereceğim ama daha iyi fikirlerle ilgileniyorum.

Şu ana kadar elimizde:

• std :: birikir ve bir xx xx xxx xdx40 std :: birikir ve bir lambda ifadesi
• düz ol 'for-loop

Başka uygulanabilir çözümler var mı? Xzx25 veya std::bind1st/2nd kullanarak bir şeyleri sürdürülebilir kılabilir misiniz?

Answer 1

, bu kısa bir halini kullanabilirsiniz: aşağı-toprak çözüm İşte

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 ve bir functor kullanın. sizin derleyici C++ 0x lambda ifadeleri destekliyorsa kendi öneriye ek olarak

#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

geçerli:

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

Boost yineleyici zerafetlerini buluyorum, ancak bunlar biraz ayrıntılı olabilir (aralık tabanlı algoritmalar bunu daha iyi yapar). Bu durumda transform iterators işi yapabilir:

#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); 

Edit: "std::mem_fn(&Foo::size)"

Düzenleme tarafından "boost::bind(&Foo::size,_1)" değiştirilir: Sadece Boost.Range kütüphane aralığı algoritmaları tanıtmak için güncellendi bulundu!

#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); 

Not: performansları yaklaşık aynıdır (yorumumu bakınız): Burada aynı çözümün yeni bir sürümüdür içten, transformedtransorm_iterator kullanır. (Ötesinde) C++ 11 kullanılarak

Answer 5

döngü

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