Question

我想知道为什么需要std::accumulate（又名减少）第3个参数。对于那些不知道accumulate是什么的人来说，它是这样使用的：

vector<int> V{1,2,3};  
int sum = accumulate(V.begin(), V.end(), 0);
// sum == 6

致电accumulate相当于：

sum = 0;  // 0 - value of 3rd param
for (auto x : V)  sum += x;

还有可选的第4个参数，允许用任何其他操作替换添加。

我听说过的理由是，如果你需要说不加，而是乘以向量的元素，我们需要其他（非零）初始值：

vector<int> V{1,2,3};
int product = accumulate(V.begin(), V.end(), 1, multiplies<int>());

但为什么不像Python一样 - 设置V.begin()的初始值，并使用从V.begin()+1开始的范围。像这样：

int sum = accumulate(V.begin()+1, V.end(), V.begin());

这适用于任何操作。为什么需要第三个参数？

Answer 1

您做出了错误的假设：T类型与InputIterator的类型相同。

但std::accumulate是通用的，允许所有不同类型的广告素材累积和缩减。

示例＃1：在员工中累积薪水

以下是一个简单示例：Employee类，包含许多数据字段。

class Employee {
/** All kinds of data: name, ID number, phone, email address... */
public:
 int monthlyPay() const;
};

你不能有意义地积累＆＃34;一组员工。这是没有意义的;它没有定义。但是，您可以定义关于员工的累积。我们假设我们要总结所有所有员工的月薪。 std::accumulate可以做到这一点：

/** Simple class defining how to add a single Employee's * monthly pay to our existing tally */ auto accumulate_func = [](int accumulator, const Employee& emp) return accumulator + emp.monthlyPay(); }; // And here's how you call the actual calculation: int TotalMonthlyPayrollCost(const vector<Employee>& V) { return std::accumulate(V.begin(), V.end(), 0, accumulate_func); }

因此，在此示例中，我们在int个对象的集合上累积Employee值。在这里，积累总和不是＆＃39; t 我们实际上总结的相同类型的变量。

示例＃2：累积平均值

您也可以将accumulate用于更复杂的累积类型 - 也许希望将值附加到向量;也许你有一些神秘的统计数据，你可以通过输入进行跟踪;等你积累的东西只是一个数字;它可能更复杂。

例如，这是一个使用accumulate计算整数向量平均值的简单示例：

// This time our accumulator isn't an int -- it's a structure that lets us // accumulate an average. struct average_accumulate_t { int sum; size_t n; double GetAverage() const { return ((double)sum)/n; } }; // Here's HOW we add a value to the average: auto func_accumulate_average = [](average_accumulate_t accAverage, int value) { return average_accumulate_t( {accAverage.sum+value, // value is added to the total sum accAverage.n+1}); // increment number of values seen }; double CalculateAverage(const vector<int>& V) { average_accumulate_t res = std::accumulate(V.begin(), V.end(), average_accumulate_t({0,0}), func_accumulate_average) return res.GetAverage(); }

示例＃3：累计平均值

您需要初始值的另一个原因是因为该值不是总是您正在进行的计算的默认/中性值。

让我们以我们已经看到的平均例子为基础。但是现在，我们想要一个可以保持运行平均值的类 - 也就是说，我们可以继续提供新值，并检查多个调用中的平均值到目前为止

class RunningAverage { average_accumulate_t _avg; public: RunningAverage():_avg({0,0}){} // initialize to empty average double AverageSoFar() const { return _avg.GetAverage(); } void AddValues(const vector<int>& v) { _avg = std::accumulate(v.begin(), v.end(), _avg, // NOT the default initial {0,0}! func_accumulate_average); } }; int main() { RunningAverage r; r.AddValues(vector<int>({1,1,1})); std::cout << "Running Average: " << r.AverageSoFar() << std::endl; // 1.0 r.AddValues(vector<int>({-1,-1,-1})); std::cout << "Running Average: " << r.AverageSoFar() << std::endl; // 0.0 }

在这种情况下，我们完全依赖于能够为std::accumulate设置初始值 - 我们需要能够从不同的起点初始化累积。

总之，std::accumulate适用于您在输入范围内迭代的任何时间，并且在该范围内构建一个结果。但结果并不需要与范围相同的类型，并且您无法对使用的初始值做出任何假设 - 这就是为什么您必须将初始实例用作累积的原因结果

Answer 2

事情的方式，对于确保范围不为空且希望从范围的第一个元素开始累积的代码来说，这很烦人。根据用于累积的操作，使用“零”值并不总是很明显。

另一方面，如果您只提供需要非空范围的版本，那么对于不确定其范围不为空的呼叫者来说这很烦人。给他们带来了额外的负担。

一个观点是两个世界中最好的当然是提供两种功能。例如，Haskell提供foldl1和foldr1（需要非空列表）以及foldl和foldr（镜像std::transform）。

另一个观点是，因为一个可以通过一个简单的转换实现另一个（正如你所证明的那样：std::transform(std::next(b), e, *b, f) - std::next是C ++ 11，但仍然是（）），最好使界面尽可能小，不会有真正的表现力损失。

Answer 3

如果你想要accumulate(V.begin()+1, V.end(), V.begin())，你可以写出来。但是如果你认为v.begin（）可能是v.end（）（即v为空）怎么办？如果没有实现v.begin() + 1会怎么样（因为v只实现++，而不是生成加法）？如果累加器的类型不是元素的类型怎么办？例如

std::accumulate(v.begin(), v.end(), 0, [](long count, char c){
   return isalpha(c) ? count + 1 : count
});

Answer 4

因为标准库算法应该适用于（兼容的）迭代器的任意范围。因此，accumulate的第一个参数不必是begin()，它可以是begin()与end()之前的任何迭代器。它也可以使用反向迭代器。

整个想法是将算法与数据分离。如果我理解正确，您的建议需要数据中的某种结构。

Answer 5

确实不需要。我们的代码库有2个和3个参数的重载，使用T{}值。

然而，std::accumulate已经很久了;它来自原始的STL。我们的代码库具有花哨的std::enable_if逻辑，用于区分“2迭代器和初始值”以及“2迭代器和缩减运算符”。这需要C ++ 11。我们的代码还使用尾随返回类型（auto accumulate(...) -> ...）来计算返回类型，这是另一个C ++ 11特性。

了解std :: accumulate

5 个答案:

示例＃1：在员工中累积薪水

示例＃2：累积平均值

示例＃3：累计平均值