函数模板
<numeric>

std::adjacent_difference

差值 (1)
template <class InputIterator, class OutputIterator>   OutputIterator adjacent_difference (InputIterator first, InputIterator last,                                       OutputIterator result);
自定义 (2)
template <class InputIterator, class OutputIterator, class BinaryOperation>   OutputIterator adjacent_difference ( InputIterator first, InputIterator last,                                        OutputIterator result, BinaryOperation binary_op );
计算范围的相邻差值
将范围[first,last)中每个元素与其前一个元素（第一个元素除外，它被赋值为*first）的差值赋给从 result 开始的目标范围中的相应元素。

如果 x 表示 [first,last) 中的一个元素，而 y 表示 result 中的一个元素，则 y 可以计算如下：

y0 = x0
y1 = x1 - x0
y2 = x2 - x1
y3 = x3 - x2
y4 = x4 - x3
... ... ...
默认操作是计算差值，但也可以将 binary_op 指定为其他操作。

此函数模板的行为等同于
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
template <class InputIterator, class OutputIterator>
   OutputIterator adjacent_difference (InputIterator first, InputIterator last,
                                       OutputIterator result)
{
  if (first!=last) {
    typename iterator_traits<InputIterator>::value_type val,prev;
    *result = prev = *first;
    while (++first!=last) {
      val = *first;
      *++result = val - prev;  // or: *++result = binary_op(val,prev)
      prev = val;
    }
    ++result;
  }
  return result;
}

参数

first, last
输入迭代器，指向序列的起始和结束位置。使用的范围是 [first,last)，它包含 first 和 last 之间的所有元素，包括 first 指向的元素，但不包括 last 指向的元素。
result
输出迭代器，指向目标序列的起始位置，差值将存储在此。范围从 result 开始，其大小应足够容纳与上述范围（[first,last)）相同数量的元素。
binary_op
二元操作，其参数是 InputIterator 指向的类型的两个元素，并返回用于替换差值操作的结果。
这可以是函数指针或函数对象。

返回值

指向目标序列中存储结果元素之后的末尾元素的迭代器。

示例

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
 
// adjacent_difference example
#include <iostream>     // std::cout
#include <functional>   // std::multiplies
#include <numeric>      // std::adjacent_difference

int myop (int x, int y) {return x+y;}

int main () {
  int val[] = {1,2,3,5,9,11,12};
  int result[7];

  std::adjacent_difference (val, val+7, result);
  std::cout << "using default adjacent_difference: ";
  for (int i=0; i<7; i++) std::cout << result[i] << ' ';
  std::cout << '\n';

  std::adjacent_difference (val, val+7, result, std::multiplies<int>());
  std::cout << "using functional operation multiplies: ";
  for (int i=0; i<7; i++) std::cout << result[i] << ' ';
  std::cout << '\n';

  std::adjacent_difference (val, val+7, result, myop);
  std::cout << "using custom function: ";
  for (int i=0; i<7; i++) std::cout << result[i] << ' ';
  std::cout << '\n';
  return 0;
}

输出

using default adjacent_difference: 1 1 1 2 4 2 1
using functional operation multiplies: 1 2 6 15 45 99 132
using custom function: 1 3 5 8 14 20 23


复杂度

线性地依赖于 first 和 last 之间的距离减一（以减法或 binary_op 的应用次数计）。

数据竞争

访问范围 [first1,last1) 中的元素（每个元素被访问一次）。
修改从 result 开始的范围中的元素。

异常

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

另见

accumulate
累加一个范围内的值 (函数模板)
inner_product
计算一个范围的累积内积 (函数模板)
partial_sum
计算一个范围的部分和 (函数模板)