c++ - 了解 std::accumulate

Question

我想知道为什么需要 std::accumulate(又名 reduce)第三个参数。对于那些不知道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;

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

我听说的基本原理是，如果您需要说不相加，而是将 vector 的元素相乘，我们需要其他(非零)初始值:

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;
};

您无法有意义地“积累”一组员工。这是没有意义的;它是未定义的。但是，您可以定义关于员工的累积。假设我们要汇总所有所有名员工的月薪。 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);
}

所以在这个例子中，我们在 Employee 对象的集合上累积一个 int 值。这里，累加和 与我们实际求和的变量类型不同。

示例 #2:累积平均值

您也可以将 accumulate 用于更复杂的累加类型 - 可能希望将值附加到 vector ；也许您在输入中跟踪了一些神秘的统计数据；等等。你积累的东西不有只是一个数字;它可能更复杂。

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

// 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:累积移动平均值

您需要初始值的另一个原因是，该值并非始终您正在进行的计算的默认/中性值。

让我们以我们已经看到的平均示例为基础。但是现在，我们想要一个能够保持 running 平均值的类——也就是说，我们可以在多个调用中不断输入新值，并检查 到目前为止 的平均值.

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 适用于您在输入范围内进行迭代并构建该范围内的单个结果的任何时候。但是结果不需要与范围的类型相同，并且您不能对要使用的初始值做出任何假设——这就是为什么您必须有一个初始实例来用作累加结果的原因。