如何使用 std::accumulate 对元素的类成员求和？

Question

我总是尽可能地尝试合并 STL 算法，而不是编写手动循环。然而，我很难理解

std::accumulate

通常是如何有用的。每当我需要计算总和或平均值时，我几乎总是最终求助于手动循环，因为我很难让

std::accumulate

来做我需要的事情。

问题是我很少有需要求和的简单整数向量。通常，我想使用特定的成员变量对对象数组求和。是的，我知道有一个版本的

std::accumulate

采用 BinaryFunction，但我看到的问题是这个函数需要采用两个

T

类型的值，其中

T

是 sum 的类型，而不是操作数的类型。我无法理解这有什么用。

考虑一个我认为很常见的案例。我有以下课程：

struct Foo
{
    Foo(int cost_, int id_) : cost(cost_), id(id_)
    { }

    int cost;
    int id;
};

现在，假设我想使用

Foo

计算

Foo::cost

对象数组的总和。

我想说：

std::vector<Foo> vec;
// fill vector with values
int total_cost = std::accumulate(vec.begin(), vec.end(), 0, sum_cost);

且

sum_cost

定义为：

int sum_cost(const Foo& f1, const Foo& f2)
{
    return f1.cost + f2.cost;
}

问题是，这不起作用，因为

std::accumulate

需要一个 BinaryFunction，它接受 结果和类型的两个实例 - 在本例中只是

int

。但这对我有什么用呢？如果我的 BinaryFunction 接受两个

int

，我无法指定要对

cost

字段求和。

那么，为什么

std::accumulate

要这样设计呢？我在这里没有看到明显的东西吗？

Answer 1

您对累加运算符采用两个相同类型的看法是错误的。仅当您愿意时它才会这样做。运算符的使用具体是

sum = op(sum, *iter)

。因此你的代码：

int count = std::accumulate(stuff.begin(), stuff.end(), 0,
                            [](int current_sum, stuff_value_t const& value) {
    return current_sum + value.member;
});

如果你不能使用 lambda，那么你当然可以使用标准绑定器或 boost::bind。

Answer 2

使用函子：

class F { // sum Foos
    F(int init = 0);
    template<class T>
    Foo operator()(const Foo &a, const T &b) const;
    operator int() const;
};

int total_cost = std::accumulate(vec.begin(), vec.end(), F(0), F());

注意你还可以做其他事情：

class F { // sum foo values members
    template<class T>
    T operator()(const T &a, const Foo &b) const;
};
int total_cost = std::accumulate(vec.begin(), vec.end(), int(0), F());