命名空间
变体
操作

std::adjacent_difference

来自 cppreference.cn
< cpp‎ | algorithm
 
C++
 
算法库
约束算法和范围上的算法 (C++20)
约束算法，例如 ranges::copy, ranges::sort, ...
执行策略 (C++17)
排序和相关操作
划分操作
排序操作
二分搜索操作
(在划分范围上)
集合操作 (在已排序范围上)
归并操作 (在已排序范围上)
堆操作
最小值/最大值操作
(C++11)
(C++17)
字典序比较操作
(C++20)
排列操作
C 库
数值操作
(C++11)
adjacent_difference
  
未初始化内存上的操作
 
数值库
 
定义于头文件 <numeric>
template< class InputIt, class OutputIt >

OutputIt adjacent_difference( InputIt first, InputIt last,

                              OutputIt d_first );
 (1) (constexpr since C++20)
template< class ExecutionPolicy,

          class ForwardIt1, class ForwardIt2 >
ForwardIt2 adjacent_difference( ExecutionPolicy&& policy,
                                ForwardIt1 first, ForwardIt1 last,

                                ForwardIt2 d_first );
 (2) (since C++17)
template< class InputIt, class OutputIt, class BinaryOp >

OutputIt adjacent_difference( InputIt first, InputIt last,

                              OutputIt d_first, BinaryOp op );
 (3) (constexpr since C++20)
template< class ExecutionPolicy,

          class ForwardIt1, class ForwardIt2, class BinaryOp >
ForwardIt2 adjacent_difference( ExecutionPolicy&& policy,
                                ForwardIt1 first, ForwardIt1 last,

                                ForwardIt2 d_first, BinaryOp op );
 (4) (since C++17)

设 T 为 decltype(first) 的值类型。

1) 如果 [first, last) 为空，则不执行任何操作。
否则，按顺序执行以下操作
  1. 创建一个类型为 T 的累加器 acc，并用 *first 初始化它。
  2. 将 acc 赋值给 *d_first。
  3. 对于 [++first, last) 中按顺序的每个迭代器 iter，按顺序执行以下操作
a) 创建一个类型为 T 的对象 val，并用 *iter 初始化它。
b) 计算 val - acc(直到 C++20)val - std::move(acc)(自 C++20 起)。
c) 将结果赋值给 *++d_first。
d) 复制(直到 C++20)移动(自 C++20 起) 从 val 赋值到 acc。
2) 如果 [first, last) 为空，则不执行任何操作。
否则，按顺序执行以下操作
  1. 将 *first 赋值给 *d_first。
  2. 对于 [1, std::distance(first, last)) 中的每个整数 i，按顺序执行以下操作
a) 计算 curr - prev，其中 curr 是 first 的第 i个 迭代器，prev 是 first 的第 i - 1个 迭代器。
b) 将结果赋值给 *dest，其中 dest 是 d_first 的第 i个 迭代器。
3) 与 (1) 相同，但计算 op(val, acc)(直到 C++20)op(val, std::move(acc))(自 C++20 起) 代替。
4) 与 (2) 相同，但计算 op(curr, prev) 代替。

给定 binary_op 作为实际的二元运算

  • 如果满足以下任一条件，则程序是非良构的
  • 对于重载 (1,3)
  • T 不能从 *first 构造。
  • acc 不可 写入 到 d_first。
  • binary_op(val, acc)(直到 C++20)binary_op(val, std::move(acc))(自 C++20 起) 的结果不可写入到 d_first。
  • 对于重载 (2,4)
  • *first 不可写入到 d_first。
  • binary_op(*first, *first) 的结果不可写入到 d_first。
  • 给定 d_last 作为要返回的迭代器，如果满足以下任一条件，则行为未定义
 (自 C++20 起)
  • 对于重载 (2,4)，[first, last) 和 [d_first, d_last) 重叠。
  • binary_op 修改了 [first, last) 或 [d_first, d_last) 的任何元素。
  • binary_op 使 [first, last] 或 [d_first, d_last] 中的任何迭代器或子范围无效。

目录

[编辑] 参数

first, last - 定义要操作的元素范围的迭代器对
d_first - 目标范围的起始迭代器
policy - 要使用的执行策略
op - 将被应用的二元运算函数对象。

函数的签名应等效于以下形式

 Ret fun(const Type1 &a, const Type2 &b);

签名不需要具有 const &。
类型  Type1 和  Type2 必须使得类型为 iterator_traits<InputIt>::value_type 的对象可以隐式转换为这两种类型。类型 Ret 必须使得类型为 OutputIt 的对象可以被解引用，并赋值类型为 Ret 的值。 ​

类型要求
-
InputIt 必须满足 LegacyInputIterator 的要求。
-
OutputIt 必须满足 LegacyOutputIterator 的要求。
-
ForwardIt1, ForwardIt2 必须满足 LegacyForwardIterator 的要求。

[编辑] 返回值

指向写入的最后一个元素之后的位置的迭代器，如果 [first, last) 为空，则返回 d_first。

[编辑] 复杂度

给定 N 为 std::distance(first, last)

1,2) 精确地 N-1 次 operator- 的应用。
3,4) 精确地 N-1 次二元函数 op 的应用。

[编辑] 异常

带有名为 ExecutionPolicy 的模板参数的重载按如下方式报告错误

  • 如果作为算法一部分调用的函数的执行抛出异常，并且 ExecutionPolicy 是标准策略之一，则调用 std::terminate。 对于任何其他 ExecutionPolicy，行为是实现定义的。
  • 如果算法无法分配内存，则会抛出 std::bad_alloc。

[编辑] 可能的实现

adjacent_difference (1) 
template<class InputIt, class OutputIt>
constexpr // since C++20
OutputIt adjacent_difference(InputIt first, InputIt last, OutputIt d_first)
{
    if (first == last)
        return d_first;
 
    typedef typename std::iterator_traits<InputIt>::value_type value_t;
    value_t acc = *first;
    *d_first = acc;
 
    while (++first != last)
    {
        value_t val = *first;
        *++d_first = val - std::move(acc); // std::move since C++20
        acc = std::move(val);
    }
 
    return ++d_first;
}
adjacent_difference (3) 
template<class InputIt, class OutputIt, class BinaryOp>
constexpr // since C++20
OutputIt adjacent_difference(InputIt first, InputIt last, 
                             OutputIt d_first, BinaryOp op)
{
    if (first == last)
        return d_first;
 
    typedef typename std::iterator_traits<InputIt>::value_type value_t;
    value_t acc = *first;
    *d_first = acc;
 
    while (++first != last)
    {
        value_t val = *first;
        *++d_first = op(val, std::move(acc)); // std::move since C++20
        acc = std::move(val);
    }
 
    return ++d_first;
}

[编辑] 注解

acc 的引入是由于 LWG issue 539 的解决。 使用 acc 而不是直接计算差值的原因是，如果以下类型不匹配，后者的语义会令人困惑

  • InputIt 的值类型
  • OutputIt 的可写类型
  • operator- 或 op 的参数类型
  • operator- 或 op 的返回类型

acc 用作缓存迭代元素值的中间对象

  • 其类型是 InputIt 的值类型
  • 写入 d_first 的值（即 operator- 或 op 的返回值）被赋值给它
  • 其值传递给 operator- 或 op
char i_array[4] = {100, 100, 100, 100};
int  o_array[4];
 
// OK: performs conversions when needed
// 1. creates “acc” of type char (the value type)
// 2. “acc” is assigned to the first element of “o_array”
// 3. the char arguments are used for long multiplication (char -> long)
// 4. the long product is assigned to the output range (long -> int)
// 5. the next value of “i_array” is assigned to “acc”
// 6. go back to step 3 to process the remaining elements in the input range
std::adjacent_difference(i_array, i_array + 4, o_array, std::multiplies<long>{});

[编辑] 示例

运行此代码
#include <array>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
 
void println(auto comment, const auto& sequence)
{
    std::cout << comment;
    for (const auto& n : sequence)
        std::cout << n << ' ';
    std::cout << '\n';
};
 
int main()
{
    // Default implementation - the difference between two adjacent items
    std::vector v{4, 6, 9, 13, 18, 19, 19, 15, 10};
    println("Initially, v = ", v);
    std::adjacent_difference(v.begin(), v.end(), v.begin());
    println("Modified v = ", v);
 
    // Fibonacci
    std::array<int, 10> a {1};
    std::adjacent_difference(std::begin(a), std::prev(std::end(a)),
                             std::next(std::begin(a)), std::plus<>{});
    println("Fibonacci, a = ", a);
}

输出

Initially, v = 4 6 9 13 18 19 19 15 10 
Modified v = 4 2 3 4 5 1 0 -4 -5 
Fibonacci, a = 1 1 2 3 5 8 13 21 34 55

[编辑] 缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的 C++ 标准。

DR 应用于 已发布行为 正确行为
LWG 242 C++98 op 不能有副作用 它不能修改
涉及的范围
LWG 539 C++98 结果所需的类型要求
评估和赋值有效性缺失		 已添加
LWG 3058 C++17 对于重载 (2,4)，每次调用的结果
operator- 或 op 被赋值给一个临时
对象，该对象被赋值给输出范围		 直接赋值结果
到输出
范围

[编辑] 参见

 计算元素范围的部分和
(函数模板) [编辑]
 对元素范围求和或折叠
(函数模板) [编辑]
Retrieved from "https://cppreference.cn/mwiki/index.php?title=cpp/algorithm/adjacent_difference&oldid=180317"