Cách tốt nhất để tổng hợp kết quả của hàm thành viên cho tất cả các phần tử trong vùng chứa là gì?

Question

Hãy nói rằng tôi có các đối tượng sau đây:

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

gì là cách tốt nhất (duy trì nhất, dễ đọc, vv) để có được tổng size của tất cả các đối tượng trong một vector<Foo>? Tôi sẽ đăng giải pháp của mình nhưng tôi quan tâm đến những ý tưởng tốt hơn.

Cập nhật:

Cho đến nay chúng ta có:

• std :: tích lũy và một functor
• std :: tích lũy và một biểu thức lambda
• đồng bằng ol' cho vòng lặp

Có giải pháp khả thi nào khác không? Bạn có thể tạo điều gì đó có thể bảo trì bằng cách sử dụng boost::bind hoặc std::bind1st/2nd không?

Answer 1

Ngoài đề nghị của riêng bạn, nếu trình biên dịch của bạn hỗ trợ C++ 0x biểu thức lambda, bạn có thể sử dụng phiên bản này ngắn hơn:

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

Sử dụng std::accumulate và hàm functor.

#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

Dưới đây là giải pháp down-to-earth:

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

Tôi tìm thấy các trình tăng tốc của bộ lặp tăng cường, mặc dù chúng có thể hơi dài dòng (các thuật toán dựa trên dải ô sẽ làm cho điều này tốt hơn). Trong trường hợp này transform iterators có thể thực hiện công việc:

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

Chỉnh sửa: thay thế "boost::bind(&Foo::size,_1)" bởi "std::mem_fn(&Foo::size)"

Chỉnh sửa: Tôi chỉ thấy rằng thư viện Boost.Range đã được cập nhật để giới thiệu các thuật toán phạm vi! Đây là một phiên bản mới của giải pháp giống nhau:

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

Lưu ý: các buổi biểu diễn là xấp xỉ như nhau (xem nhận xét của tôi): trong nội bộ, sử dụng transformedtransorm_iterator.

Answer 5

sử dụng C++ 11 (và xa hơn nữa) phạm vi dựa trên vòng lặp for

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