Jaki jest najlepszy sposób na zsumowanie wyniku funkcji składowej dla wszystkich elementów w kontenerze?

Question

Powiedzmy mam następujący obiekt:

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

Jaki jest najlepszy sposób (najbardziej utrzymaniu, czytelne, itd.), Aby uzyskać całkowitą size wszystkich obiektów w vector<Foo>? Opublikuję moje rozwiązanie, ale interesują mnie lepsze pomysły.

Aktualizacja:

tej pory mamy:

• std :: gromadzić i funktor
• std :: gromadzić i wyrażenie lambda
• zwykły ol”dla pętli

Czy istnieją inne możliwe do zastosowania rozwiązania? Czy możesz stworzyć coś możliwego do utrzymania przy użyciu boost::bind lub std::bind1st/2nd?

Answer 1

Oprócz własnych sugestii, jeśli kompilator C++ 0x obsługuje wyrażeń lambda, można użyć tej krótszą wersję:

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

Użyj std::accumulate i funktora.

#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

Oto rozwiązanie down-to-earth:

Answer 4

Znajduję wzmacniające iteratory elegants, chociaż mogą być nieco szczegółowe (algorytmy oparte na odległościach sprawiają, że jest to lepsze). W tym przypadku transform iterators może wykonać zadanie:

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

Edycja: zastąpiona "boost::bind(&Foo::size,_1)" przez "std::mem_fn(&Foo::size)"

Edit: Właśnie okazało się, że biblioteka Boost.Range został zaktualizowany do wprowadzenia algorytmów zasięgu! Oto nowa wersja tego samego roztworu:

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

Uwaga: występy są w przybliżeniu takie same (patrz mój komentarz): wewnętrznie, transformed wykorzystuje transorm_iterator.

Answer 5

przy użyciu C++ 11 (oraz poza) Zakres na bazie pętli

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