函数模板
<numeric>

std::accumulate

sum (1)
template <class InputIterator, class T>   T accumulate (InputIterator first, InputIterator last, T init);
自定义 (2)
template <class InputIterator, class T, class BinaryOperation>   T accumulate (InputIterator first, InputIterator last, T init,                 BinaryOperation binary_op);
累加范围中的值
返回将范围 [first,last) 中所有值累加到 init 的结果。

默认操作是加法，但也可以指定其他操作作为 binary_op。

此函数模板的行为等同于
1
2
3
4
5
6
7
8
9
 
template <class InputIterator, class T>
   T accumulate (InputIterator first, InputIterator last, T init)
{
  while (first!=last) {
    init = init + *first;  // or: init=binary_op(init,*first) for the binary_op version
    ++first;
  }
  return init;
}

参数

first, last
输入迭代器，指向序列的起始和结束位置。使用的范围是 [first,last)，它包含 first 和 last 之间的所有元素，包括 first 指向的元素，但不包括 last 指向的元素。
init
累加器的初始值。
binary_op
二元操作，接受一个类型为 T 的元素作为第一个参数，以及范围中的一个元素作为第二个参数，并返回一个可以赋给类型 T 的值。
这可以是指向函数的指针，也可以是函数对象。
该操作不应修改作为其参数传递的元素。

返回值

累加 init 和范围 [first,last) 中所有元素的结果。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
// accumulate example
#include <iostream>     // std::cout
#include <functional>   // std::minus
#include <numeric>      // std::accumulate

int myfunction (int x, int y) {return x+2*y;}
struct myclass {
	int operator()(int x, int y) {return x+3*y;}
} myobject;

int main () {
  int init = 100;
  int numbers[] = {10,20,30};

  std::cout << "using default accumulate: ";
  std::cout << std::accumulate(numbers,numbers+3,init);
  std::cout << '\n';

  std::cout << "using functional's minus: ";
  std::cout << std::accumulate (numbers, numbers+3, init, std::minus<int>());
  std::cout << '\n';

  std::cout << "using custom function: ";
  std::cout << std::accumulate (numbers, numbers+3, init, myfunction);
  std::cout << '\n';

  std::cout << "using custom object: ";
  std::cout << std::accumulate (numbers, numbers+3, init, myobject);
  std::cout << '\n';

  return 0;
}

输出

using default accumulate: 160
using functional's minus: 40
using custom function: 220
using custom object: 280


复杂度

线性的，与 first 和 last 之间的 距离 成比例。

数据竞争

范围 [first,last) 中的元素被访问（每个元素被访问一次）。

异常

如果 binary_op、赋值或迭代器上的操作抛出异常，则本函数也抛出异常。
请注意，无效参数会导致未定义行为。

另见

inner_product
计算一个范围的累积内积 (函数模板)
partial_sum
计算一个范围的部分和 (函数模板)
adjacent_difference
计算一个范围内的相邻差值 (函数模板)